Fremstilling af HTTP-anmodninger i rust med Reqwest

Som de fleste programmeringssprog kan du bruge Rust til at sende og modtage data over HTTP. Når du bygger en webbaseret tjeneste, skal du ofte integrere en eller flere tjenester. Du vil ofte gøre det ved at sende dem HTTP-anmodninger.

Rust har indbygget funktionalitet til HTTP-operationer. Der er også mange biblioteker i Rust-økosystemet, der hjælper dig med at interagere med HTTP og bygge HTTP-tjenester.

Fremstilling af HTTP-anmodninger med rust

Adskillige Rust-biblioteker er tilgængelige til at lave HTTP-anmodninger, herunder Reqwest, Hyper, og Surf biblioteker. Reqwest er den mest populære blandt Rust-udviklere.

Reqwest er et klientbibliotek på højt niveau, der giver en enkel og bekvem API til at lave HTTP-anmodninger. Reqwest leverer funktionalitet til at sende forespørgsler og håndtere svar og fejl. Det abstraherer mange detaljer bag at lave en HTTP-anmodning og understøtter avancerede funktioner som asynkrone anmodninger ved hjælp af

tokio køretid. Det håndterer også JSON-deserialisering, HTTP-headere, forbindelsestimeouts og SSL-indstillinger.

Du vil finde Reqwest-biblioteket praktisk, hvis du er ny til Rust eller mangler erfaring med HTTP-tjenester.

For at starte med Reqwest skal du tilføje Reqwest og Tokyo biblioteker til dit projekts afhængigheder. Tokio er et asynkront runtime-bibliotek, der interopererer med Reqwest. Du kan tilføje disse afhængigheder til din Cargo.toml fil efter oprettelse af et Rust-projekt.

[afhængigheder]
tokio = { version = "1.15", funktioner = ["fuld"] }
reqwest = { version = "0.11", funktioner = ["json"] }

Når du har tilføjet Reqwest- og Tokio-bibliotekerne til dit projekts afhængigheder, installerer Cargo dem, når du bygger dit program.

HTTP GET-anmodninger med Reqwest

Du vil lave GET-anmodninger om at hente data fra en webserver. GET-anmodninger kan hente HTML-sider, JSON-data eller binære filer som billeder eller videoer.

Reqwest lader dig angive URL-slutpunktet som en streng sammen med forespørgselsparametre og overskrifter for anmodningen.

Sådan kan du sende en HTTP GET-anmodning til en URL:

brug reqwest:: Fejl;
asynkronfnfå_anmodning() -> Resultat {
lade respons = reqwest:: get(" https://www.example.com").vente?;
println!("Status: {}", response.status());
lade body = respons.tekst().vente?;
println!("Krop:\n{}", krop);
Okay(())
}
#[tokio:: main]
asynkronfnvigtigste() -> Resultat {
 get_request().vente?;
Okay(())
}

Denne kode definerer en asynkron funktion, få_anmodning, for at udskrive svardetaljer fra en anmodning til example.com. Det kalder reqwest moduler få metode og udskriver svarets statuskode og krop.

Her er resultatet af at ringe til få_anmodning funktion fra vigtigste fungere:

Håndtering af HTTP-fejl med Reqwest

Du skal håndtere fejl fra HTTP-anmodninger, når de opstår. Reqwest-biblioteket giver en Fejl type, som du kan bruge til at håndtere fejl. Derudover kan HTTP-statuskoder fra webserveren give oplysninger om anmodningens status.

Sådan kan du håndtere HTTP-fejl for dine anmodninger med Reqwest:

brug reqwest:: Fejl;
asynkronfnhandle_error() -> Resultat {
lade respons = reqwest:: get(" https://www.example.com").vente?;
match response.status().as_u16() {
200..=299 => {
lade body = respons.tekst().vente?;
println!("Succes! Body:\n{}", krop);
 }
400..=599 => {
lade status = respons.status();
lade error_message = response.text().vente?;
println!("Fejl {}: {}", status, fejlmeddelelse);
 }
 _ => {
println!("Uventet statuskode: {}", response.status());
 }
 }
Okay(())
}
#[tokio:: main]
asynkronfnvigtigste() -> Resultat {
 handle_error().vente?;
Okay(())
}

Det handle_error funktion laver en GET-anmodning til eksempel.com, og match-sætningen håndterer eventuelle fejl baseret på svarstatuskoden.

Funktionen udskriver en besked og statuskoden afhængigt af svaret til serveren.

Afsendelse af HTTP POST-anmodninger med Reqwest

Du skal lave HTTP POST-anmodninger om at sende data til en server. Du kan gøre det ved at bruge reqwest:: Kunde struct, der opretter en klient og bruger reqwest:: RequestBuilder struct for at opbygge anmodningen.

Sådan kan du lave en POST-anmodning til HTTPbins POST-anmodningsslutpunkt med Reqwest:

brug reqwest::{Client, Error};
asynkronfnPost-it() -> Resultat {
lade url = " https://httpbin.org/post";
lade json_data = r#"{"name": "John Doe", "email": "[email protected]"}"#;
lade klient = reqwest:: Client:: new();
lade svar = klient
 .post (webadresse)
 .header("Indholdstype", "applikation/json")
 .body (json_data.to_owned())
 .sende()
 .vente?;
println!("Status: {}", response.status());
lade response_body = respons.tekst().vente?;
println!("Svartekst:\n{}", response_body);
Okay(())
}
#[tokio:: main]
asynkronfnvigtigste() -> Resultat {
 Post-it().vente?;
Okay(())
}

Det json_data variabel definerer JSON-dataene for anmodningen, og klient variabel er en reqwest:: Kunde instans for POST-anmodningen.

Det respons variabel er POST-anmodningsbyggeren. Det stolpe metoden sender POST-anmodningen til URL'en, og header metode indstiller en HTTP-header. Det legeme metode indstiller anmodningslegemet, og sende metoden sender anmodningen.

Det Post-it funktion udskriver svarstatuskoden og brødteksten til konsollen ved hjælp af println! makro:

Håndtering af overskrifter og forespørgselsparametre Dine HTTP-anmodninger

Håndtering af overskrifter og forespørgselsparametre er et vigtigt aspekt ved at lave HTTP-anmodninger. Overskrifter indeholder yderligere oplysninger såsom godkendelsesoplysninger eller metadata om det anmodede indhold.

Du skal bruge forespørgselsparametre til at tilføje yderligere oplysninger til en URL, så serveren kan filtrere eller ændre et svar.

Håndtering af overskrifter og forespørgselsparametre følger en lignende proces til at sende postanmodninger. Sådan kan du håndtere overskrifter og forespørgselsparametre i dine HTTP-anmodninger med Reqwest:

brug std:: samlinger:: HashMap;
brug reqwest::{ Fejl, header};
#[tokio:: main]
asynkronfnvigtigste() -> Resultat {
 headers_for_requests().vente?;
Okay(())
}
asynkronfnheaders_for_requests() -> Resultat {
// Indstil URL'en og overskrifterne for anmodningen
lade url = " https://example.com/api";
lademut headers = header:: HeaderMap:: new();
 headers.insert (header:: USER_AGENT, header:: HeaderValue:: from_static("reqwest"));
 headers.insert (header:: CONTENT_TYPE, header:: HeaderValue:: from_static("applikation/json"));
// Indstil forespørgselsparametrene for anmodningen
lademut params = HashMap:: new();
 params.insert("foo", "bar");
 params.insert("baz", "qux");
// Lav anmodningen
lade respons = reqwest:: Client:: new()
 .get (url)
 .headers (headers)
 .query(&params)
 .sende()
 .vente?;
// Håndter svaret
println!("{:#?}", respons);
Okay(())
}

Du opretter et hashmap for forespørgselsparametrene, som du derefter sender til forespørgsel metode. Opret en instans af header:: HeaderMap skriv for at tilføje overskrifter.

Det headers_for_requests funktionen sender en GET-anmodning til eksempel.com med flere overskrifter og forespørgselsparametre. Den bruger overskrifter og forespørgsel metoder, der tager kort, der indeholder henholdsvis overskrifter og forespørgselsparametre.

Du kan bygge Full Stack WebApp i rust med WASM

At lave HTTP-anmodninger er en færdighed, der er praktisk til at bygge sofistikerede applikationer, der integrerer funktionalitet fra andre applikationer.

Du kan bygge fuldstack-webapplikationer i Rust med biblioteker som Percy, Yew og Sycamore, der abstraherer kompleksiteten for fremragende udviklingsoplevelse.