HTTP-Anfragen in Rust mit Reqwest stellen

Wie die meisten Programmiersprachen können Sie mit Rust Daten über HTTP senden und empfangen. Wenn Sie einen webbasierten Dienst erstellen, müssen Sie häufig einen oder mehrere Dienste integrieren. Sie tun dies oft, indem Sie ihnen HTTP-Anfragen senden.

Rust hat eine eingebaute Funktionalität für HTTP-Operationen. Es gibt auch viele Bibliotheken im Rust-Ökosystem, die Ihnen helfen, mit HTTP zu interagieren und HTTP-Dienste zu erstellen.

HTTP-Requests mit Rust erstellen

Es stehen mehrere Rust-Bibliotheken zum Erstellen von HTTP-Anforderungen zur Verfügung, einschließlich der Anfrage, Hyper, Und Surfen Bibliotheken. Reqwest ist das beliebteste unter Rust-Entwicklern.

Reqwest ist eine High-Level-Client-Bibliothek, die eine einfache und bequeme API zum Erstellen von HTTP-Anforderungen bereitstellt. Reqwest bietet Funktionen zum Senden von Anfragen und zum Behandeln von Antworten und Fehlern. Es abstrahiert viele Details hinter dem Erstellen einer HTTP-Anfrage und unterstützt erweiterte Funktionen wie asynchrone Anfragen mit der

Tokio Laufzeit. Es verarbeitet auch JSON-Deserialisierung, HTTP-Header, Verbindungszeitüberschreitungen und SSL-Einstellungen.

Sie finden die Reqwest-Bibliothek praktisch, wenn Sie neu bei Rust sind oder keine Erfahrung mit HTTP-Diensten haben.

Um mit Reqwest zu beginnen, fügen Sie Reqwest und hinzu Tokyo Bibliotheken zu den Abhängigkeiten Ihres Projekts. Tokio ist eine asynchrone Laufzeitbibliothek, die mit Reqwest interagiert. Sie können diese Abhängigkeiten zu Ihrer hinzufügen Fracht.toml Datei nach dem Erstellen eines Rust-Projekts.

[Abhängigkeiten]
Tokio = {Version = "1.15", Funktionen = ["voll"] }
anfordern = {Version = "0.11", Funktionen = ["json"] }

Sobald Sie die Reqwest- und Tokio-Bibliotheken zu den Abhängigkeiten Ihres Projekts hinzugefügt haben, installiert Cargo sie, wenn Sie Ihr Programm erstellen.

HTTP-GET-Anforderungen mit Reqwest

Sie stellen GET-Anforderungen, um Daten von einem Webserver abzurufen. GET-Anforderungen können HTML-Seiten, JSON-Daten oder abrufen Binärdateien wie Bilder oder Videos.

Mit Reqwest können Sie den URL-Endpunkt als Zeichenfolge zusammen mit Abfrageparametern und Headern für die Anforderung angeben.

So können Sie eine HTTP-GET-Anforderung an eine URL senden:

verwenden reqwest:: Fehler;
asynchronfnget_request() -> Ergebnis {
lassen Antwort = Anfrage:: get(" https://www.example.com").erwarten?;
drucken!("Status: {}", Antwort.status());
lassen body = antwort.text().erwarten?;
drucken!("Text:\n{}", Körper);
OK(())
}
#[tokio:: haupt]
asynchronfnhauptsächlich() -> Ergebnis {
 get_request().erwarten?;
OK(())
}

Dieser Code definiert eine asynchrone Funktion, get_request, um Antwortdetails von einer Anfrage an example.com zu drucken. Es ruft die anfordern Moduls erhalten Methode und druckt die Statuscode der Antwort und Körper.

Hier ist das Ergebnis des Aufrufs von get_request Funktion aus der hauptsächlich Funktion:

Behandlung von HTTP-Fehlern mit Reqwest

Sie müssen Fehler von HTTP-Anforderungen behandeln, wenn sie auftreten. Die Reqwest-Bibliothek bietet eine Fehler Typ, den Sie verwenden können, um Fehler zu behandeln. Zusätzlich können HTTP-Statuscodes vom Webserver Auskunft über den Status der Anfrage geben.

So können Sie HTTP-Fehler für Ihre Anfragen mit Reqwest behandeln:

verwenden reqwest:: Fehler;
asynchronfnhandle_error() -> Ergebnis {
lassen Antwort = Anfrage:: get(" https://www.example.com").erwarten?;
passen Antwort.status().as_u16() {
200..=299 => {
lassen body = antwort.text().erwarten?;
drucken!("Erfolg! Körper:\n{}", Körper);
 }
400..=599 => {
lassen status = antwort.status();
lassen error_message = antwort.text().erwarten?;
drucken!("Fehler {}: {}", Status, Fehlermeldung);
 }
 _ => {
drucken!("Unerwarteter Statuscode: {}", Antwort.status());
 }
 }
OK(())
}
#[tokio:: haupt]
asynchronfnhauptsächlich() -> Ergebnis {
 handle_error().erwarten?;
OK(())
}

Der handle_error Funktion macht eine GET-Anforderung an beispiel.com, und die match-Anweisung behandelt alle Fehler basierend auf dem Antwortstatuscode.

Die Funktion gibt abhängig von der Antwort an den Server eine Nachricht und den Statuscode aus.

Senden von HTTP-POST-Anforderungen mit Reqwest

Sie stellen HTTP-POST-Anforderungen, um Daten an einen Server zu senden. Sie können dies tun, indem Sie die reqwest:: Kunde struct, die einen Client erstellt und die verwendet reqwest:: RequestBuilder struct zum Erstellen der Anfrage.

So können Sie eine POST-Anfrage an stellen POST-Anforderungsendpunkt von HTTPbin mit Reqwest:

verwenden reqwest::{Client, Fehler};
asynchronfnveröffentliche es() -> Ergebnis {
lassen url = " https://httpbin.org/post";
lassen json_data = r#"{"name": "John Doe", "email": "[email protected]"}"#;
lassen client = reqwest:: Client:: new();
lassen Antwort = Kunde
 .post (URL)
 .Header("Inhaltstyp", "Anwendung/json")
 .body (json_data.to_owned())
 .schicken()
 .erwarten?;
drucken!("Status: {}", Antwort.status());
lassen antwort_körper = antwort.text().erwarten?;
drucken!("Antworttext:\n{}", Antworttext);
OK(())
}
#[tokio:: haupt]
asynchronfnhauptsächlich() -> Ergebnis {
 veröffentliche es().erwarten?;
OK(())
}

Der json_data -Variable definiert die JSON-Daten für die Anfrage und die Klient Variable ist ein reqwest:: Kunde Instanz für die POST-Anforderung.

Der Antwort Variable ist der POST-Request-Builder. Der Post -Methode sendet die POST-Anfrage an die URL und die Header -Methode legt einen HTTP-Header fest. Der Körper -Methode legt den Anforderungstext fest, und die schicken Methode sendet die Anfrage.

Der veröffentliche es -Funktion gibt den Statuscode und den Text der Antwort mithilfe von auf der Konsole aus drucken! Makro:

Umgang mit Headern und Abfrageparametern Ihrer HTTP-Anforderungen

Die Handhabung von Headern und Abfrageparametern ist ein wichtiger Aspekt beim Erstellen von HTTP-Anforderungen. Header enthalten zusätzliche Informationen wie Authentifizierungsdaten oder Metadaten zum angeforderten Inhalt.

Sie verwenden Abfrageparameter, um einer URL zusätzliche Informationen hinzuzufügen, damit der Server eine Antwort filtern oder ändern kann.

Die Handhabung von Headern und Abfrageparametern folgt einem ähnlichen Prozess wie das Senden von Post-Requests. So können Sie Header und Abfrageparameter in Ihren HTTP-Anforderungen mit Reqwest handhaben:

verwenden std:: collections:: HashMap;
verwenden reqwest::{ Fehler, Header};
#[tokio:: haupt]
asynchronfnhauptsächlich() -> Ergebnis {
 headers_for_requests().erwarten?;
OK(())
}
asynchronfnheaders_for_requests() -> Ergebnis {
// URL und Header für die Anfrage einrichten
lassen url = " https://example.com/api";
lassenmut headers = header:: HeaderMap:: new();
 headers.insert (header:: USER_AGENT, header:: HeaderValue:: from_static("Anfrage"));
 headers.insert (header:: CONTENT_TYPE, header:: HeaderValue:: from_static("Anwendung/json"));
// Richten Sie die Abfrageparameter für die Anfrage ein
lassenmut Parameter = HashMap:: new();
 params.insert("Foo", "Bar");
 params.insert("baz", "qux");
// Anfrage stellen
lassen response = reqwest:: Client:: new()
 .get (URL)
 .header (Überschriften)
 .query(&params)
 .schicken()
 .erwarten?;
// Antwort verarbeiten
drucken!("{:#?}", Antwort);
OK(())
}

Sie erstellen eine Hashmap für die Abfrageparameter, die Sie dann an die übergeben Anfrage Methode. Erstellen Sie eine Instanz der header:: HeaderMap eingeben, um Kopfzeilen hinzuzufügen.

Der headers_for_requests Funktion sendet eine GET-Anforderung an beispiel.com mit mehreren Headern und Abfrageparametern. Es verwendet die Kopfzeilen Und Anfrage Methoden, die Karten verwenden, die die Header bzw. Abfrageparameter enthalten.

Mit WASM können Sie eine Full-Stack-WebApp in Rust erstellen

Das Erstellen von HTTP-Anforderungen ist eine praktische Fähigkeit zum Erstellen anspruchsvoller Anwendungen, die Funktionen aus anderen Anwendungen integrieren.

Sie können Full-Stack-Webanwendungen in Rust mit Bibliotheken wie Percy, Yew und Sycamore erstellen, die Komplexitäten für eine hervorragende Entwicklungserfahrung abstrahieren.