#Reqwest: Rust HTTP-Client-Bibliothek

Reqwest ist eine hochwertige HTTP-Client-Bibliothek, die die HTTP-Anfrageverarbeitung vereinfacht und viele häufig verwendete Funktionen bereitstellt:

• Unterstützung für asynchrone und blockierende APIs
• Verarbeitung verschiedener Arten von Anfragekörpern: Klartext, JSON, URL-kodierte Formulare, Multipart-Formulare
• Anpassbare Weiterleitungsrichtlinien
• HTTP-Proxy-Unterstützung
• Standardmäßig aktivierte TLS-Verschlüsselung
• Cookie-Verwaltung

#Grundlegende Verwendung

#Eine GET-Anfrage stellen

Für einzelne Anfragen können Sie die praktische Methode get verwenden:

let body = reqwest::get("https://www.rust-lang.org")
    .await?
    .text()
    .await?;

println!("body = {body:?}");

Hinweis: Wenn Sie mehrere Anfragen planen, ist es besser, einen Client zu erstellen und ihn wiederzuverwenden, um von der Verbindungspooling zu profitieren.

let client = reqwest::Client::new();
let res = client.get("https://www.rust-lang.org")
    .send()
    .await?;

#Eine POST-Anfrage stellen

Sie können den Anfragekörper mit der Methode body() festlegen:

let client = reqwest::Client::new();
let res = client.post("http://httpbin.org/post")
    .body("the exact body that is sent")
    .send()
    .await?;

#Formulardaten

Das Senden von Formulardaten ist eine häufige Anforderung. Sie können jeden Typ verwenden, der in Formulardaten serialisiert werden kann:

// Dies sendet eine POST-Anfrage mit dem Körper `foo=bar&baz=quux`
let params = [("foo", "bar"), ("baz", "quux")];
let client = reqwest::Client::new();
let res = client.post("http://httpbin.org/post")
    .form(&params)
    .send()
    .await?;

#JSON-Daten

Sie können JSON-Daten einfach mit der Methode json senden (erfordert das json-Feature):

// Dies sendet eine POST-Anfrage mit dem Körper `{"lang":"rust","body":"json"}`
let mut map = HashMap::new();
map.insert("lang", "rust");
map.insert("body", "json");

let client = reqwest::Client::new();
let res = client.post("http://httpbin.org/post")
    .json(&map)
    .send()
    .await?;

#Antwortverarbeitung

Antworten können auf verschiedene Arten verarbeitet werden:

let res = client.get("https://www.rust-lang.org").send().await?;

// Statuscode abrufen
let status = res.status();

// Antwort-Header abrufen
let content_type = res.headers().get("content-type").unwrap();

// Antwortkörper als Text lesen
let body = res.text().await?;

// Oder als JSON parsen
let json: serde_json::Value = res.json().await?;

#Erweiterte Funktionen

#Weiterleitungsrichtlinie

Standardmäßig verarbeitet der Client HTTP-Weiterleitungen automatisch und folgt bis zu 10 Sprüngen. Sie können dieses Verhalten mit ClientBuilder anpassen:

let custom_client = reqwest::Client::builder()
    .redirect(reqwest::redirect::Policy::none()) // Weiterleitungen deaktivieren
    .build()?;

#Cookie-Unterstützung

Sie können die automatische Speicherung und das Senden von Sitzungs-Cookies über ClientBuilder aktivieren:

let client = reqwest::Client::builder()
    .cookie_store(true)
    .build()?;

#Proxy-Einstellungen

Systemproxys sind standardmäßig aktiviert, die nach HTTP- oder HTTPS-Proxy-Einstellungen in Umgebungsvariablen suchen:

• HTTP_PROXY oder http_proxy: Proxy für HTTP-Verbindungen
• HTTPS_PROXY oder https_proxy: Proxy für HTTPS-Verbindungen
• ALL_PROXY oder all_proxy: Proxy für beide Arten von Verbindungen

Sie können auch explizit einen Proxy über Code festlegen:

let proxy = reqwest::Proxy::http("https://secure.example")?;
let client = reqwest::Client::builder()
    .proxy(proxy)
    .build()?;

// Oder Proxys deaktivieren
let client = reqwest::Client::builder()
    .no_proxy()
    .build()?;

#TLS-Konfiguration

Der Client verwendet standardmäßig TLS, um sich mit HTTPS-Zielen zu verbinden:

// Zusätzliche Serverzertifikate hinzufügen
let cert = reqwest::Certificate::from_pem(&cert_bytes)?;
let client = reqwest::Client::builder()
    .add_root_certificate(cert)
    .build()?;

// Client-Zertifikate konfigurieren
let identity = reqwest::Identity::from_pkcs12_der(&pkcs12_der, "password")?;
let client = reqwest::Client::builder()
    .identity(identity)
    .build()?;

#Timeout-Einstellungen

Sie können Timeout-Dauern für Anfragen konfigurieren:

let client = reqwest::Client::builder()
    .timeout(std::time::Duration::from_secs(10))
    .build()?;

#Optionale Funktionen

Reqwest bietet verschiedene optionale Funktionen, die über Cargo-Features aktiviert oder deaktiviert werden können:

• http2 (standardmäßig aktiviert): Unterstützung für HTTP/2
• default-tls (standardmäßig aktiviert): bietet TLS-Unterstützung für HTTPS
• rustls-tls: bietet TLS-Funktionalität mit rustls
• blocking: bietet eine blockierende Client-API
• json: bietet JSON-Serialisierungs- und Deserialisierungsfunktionalität
• multipart: bietet Multipart-Formularfunktionalität
• cookies: bietet Cookie-Sitzungsunterstützung
• gzip, brotli, deflate, zstd: Unterstützung für verschiedene Antwortkörper-Dekompression
• socks: bietet SOCKS5-Proxy-Unterstützung

#Blockierende API

Wenn asynchrone Operationen nicht benötigt werden, können Sie die blockierende API verwenden (erfordert das blocking-Feature):

let body = reqwest::blocking::get("https://www.rust-lang.org")?.text()?;

let client = reqwest::blocking::Client::new();
let res = client.post("http://httpbin.org/post")
    .json(&map)
    .send()?;