HTTP pieprasījumu veikšana Rust, izmantojot Reqwest

Tāpat kā lielākā daļa programmēšanas valodu, jūs varat izmantot Rust, lai nosūtītu un saņemtu datus, izmantojot HTTP. Veidojot tīmekļa pakalpojumu, jums bieži būs jāintegrē viens vai vairāki pakalpojumi. Jūs bieži to darīsit, nosūtot viņiem HTTP pieprasījumus.

Rust ir iebūvēta funkcionalitāte HTTP darbībām. Rust ekosistēmā ir arī daudzas bibliotēkas, kas palīdz mijiedarboties ar HTTP un izveidot HTTP pakalpojumus.

HTTP pieprasījumu veikšana, izmantojot Rust

HTTP pieprasījumu veikšanai ir pieejamas vairākas Rust bibliotēkas, tostarp Reqwest, Hiper, un Sērfot bibliotēkas. Reqwest ir vispopulārākais Rust izstrādātāju vidū.

Reqwest ir augsta līmeņa klientu bibliotēka, kas nodrošina vienkāršu un ērtu API HTTP pieprasījumu veikšanai. Reqwest nodrošina funkcionalitāti pieprasījumu nosūtīšanai un atbilžu un kļūdu apstrādei. Tas apkopo daudzas HTTP pieprasījuma veikšanas detaļas un atbalsta uzlabotas funkcijas, piemēram, asinhronos pieprasījumus, izmantojot

tokio izpildlaiks. Tas arī apstrādā JSON deserializāciju, HTTP galvenes, savienojuma taimautus un SSL iestatījumus.

Reqwest bibliotēka būs noderīga, ja esat iesācējs Rust vai jums trūkst pieredzes ar HTTP pakalpojumiem.

Lai sāktu ar Reqwest, pievienojiet Reqwest un Tokio bibliotēkas jūsu projekta atkarībām. Tokio ir asinhrona izpildlaika bibliotēka, kas sadarbojas ar Reqwest. Varat pievienot šīs atkarības savam Krava.toml failu pēc Rust projekta izveides.

[atkarības]
tokio = { versija = "1.15", funkcijas = ["pilns"] }
reqwest = { versija = "0.11", funkcijas = ["json"] }

Kad esat pievienojis Reqwest un Tokio bibliotēkas sava projekta atkarībām, Cargo tās instalēs, kad veidosit savu programmu.

HTTP GET pieprasījumi, izmantojot Reqwest

Jūs veiksit GET pieprasījumus, lai izgūtu datus no tīmekļa servera. GET pieprasījumi var izgūt HTML lapas, JSON datus vai bināros failus, piemēram, attēlus vai videoklipus.

Reqwest ļauj norādīt URL galapunktu kā virkni kopā ar vaicājuma parametriem un pieprasījuma galvenēm.

Lūk, kā varat nosūtīt HTTP GET pieprasījumu uz URL:

izmantot reqwest:: Kļūda;
asinhronsfnget_request() -> Rezultāts {
ļaut atbilde = reqwest:: get(" https://www.example.com").gaidīt?;
println!("Statuss: {}", atbilde.statuss());
ļaut body = atbilde.text().gaidīt?;
println!("Pamatteksts:\n{}", korpuss);
Labi(())
}
#[tokio:: galvenais]
asinhronsfngalvenais() -> Rezultāts {
 get_request().gaidīt?;
Labi(())
}

Šis kods definē asinhrono funkciju, get_request, lai izdrukātu atbildes informāciju no pieprasījuma uz example.com. To sauc par reqwest modulis gūt metodi un izdrukā atbildes statusa kods un ķermenis.

Šeit ir zvanīšanas rezultāts get_request funkcija no galvenais funkcija:

HTTP kļūdu apstrāde, izmantojot Reqwest

Jums būs jāapstrādā kļūdas no HTTP pieprasījumiem, kad tās rodas. Reqwest bibliotēka nodrošina Kļūda veidu, ko varat izmantot kļūdu novēršanai. Turklāt HTTP statusa kodi no tīmekļa servera var sniegt informāciju par pieprasījuma statusu.

Lūk, kā varat apstrādāt HTTP kļūdas saviem pieprasījumiem, izmantojot Reqwest:

izmantot reqwest:: Kļūda;
asinhronsfnhand_error() -> Rezultāts {
ļaut atbilde = reqwest:: get(" https://www.example.com").gaidīt?;
atbilst response.status().as_u16() {
200..=299 => {
ļaut body = atbilde.text().gaidīt?;
println!("Veiksmi! Pamatteksts:\n{}", korpuss);
 }
400..=599 => {
ļaut statuss = atbilde.statuss();
ļaut error_message = atbilde.teksts().gaidīt?;
println!("Kļūda {}: {}", statuss, error_message);
 }
 _ => {
println!("Negaidīts statusa kods: {}", atbilde.statuss());
 }
 }
Labi(())
}
#[tokio:: galvenais]
asinhronsfngalvenais() -> Rezultāts {
 hand_error().gaidīt?;
Labi(())
}

The hand_error funkcija veic GET pieprasījumu example.com, un atbilstības paziņojums apstrādā visas kļūdas, pamatojoties uz atbildes statusa kodu.

Funkcija izdrukā ziņojumu un statusa kodu atkarībā no atbildes uz serveri.

HTTP POST pieprasījumu sūtīšana, izmantojot Reqwest

Jūs veiksit HTTP POST pieprasījumus, lai iesniegtu datus serverī. To var izdarīt, izmantojot reqwest:: Klients struktūra, kas izveido klientu un izmanto reqwest:: RequestBuilder struktūra, lai izveidotu pieprasījumu.

Lūk, kā varat veikt POST pieprasījumu HTTPbin POST pieprasījuma galapunkts ar pieprasījumu:

izmantot reqwest::{Klients, kļūda};
asinhronsfnpublicē to() -> Rezultāts {
ļaut url = " https://httpbin.org/post";
ļaut json_data = r#"{"nosaukums": "Džons Doe", "e-pasts": "[email protected]"}"#;
ļaut klients = reqwest:: Klients:: jauns();
ļaut atbilde = klients
 .post (url)
 .header("Satura veids", "aplikācija/json")
 .body (json_data.to_owned())
 .send()
 .gaidīt?;
println!("Statuss: {}", atbilde.statuss());
ļaut atbildes_ķermenis = atbilde.teksts().gaidīt?;
println!("Atbildes pamatteksts:\n{}", atbildes_ķermenis);
Labi(())
}
#[tokio:: galvenais]
asinhronsfngalvenais() -> Rezultāts {
 publicē to().gaidīt?;
Labi(())
}

The json_data mainīgais definē pieprasījuma JSON datus un klients mainīgais ir a reqwest:: Klients piemēram POST pieprasījumam.

The atbildi mainīgais ir POST pieprasījuma veidotājs. The pastu metode nosūta POST pieprasījumu uz URL, un galvene metode iestata HTTP galveni. The ķermeni metode nosaka pieprasījuma pamattekstu un nosūtīt metode nosūta pieprasījumu.

The publicē to funkcija drukā atbildes statusa kodu un pamattekstu konsolē, izmantojot println! makro:

HTTP pieprasījumu galveņu un vaicājumu parametru apstrāde

Galvenju un vaicājuma parametru apstrāde ir svarīgs HTTP pieprasījumu veikšanas aspekts. Galvenes satur papildu informāciju, piemēram, autentifikācijas akreditācijas datus vai metadatus par pieprasīto saturu.

Vaicājuma parametri tiks izmantoti, lai vietrādim URL pievienotu papildu informāciju, lai serveris filtrētu vai modificētu atbildi.

Galvenju un vaicājuma parametru apstrāde notiek līdzīgi kā ziņu pieprasījumu nosūtīšana. Lūk, kā varat apstrādāt galvenes un vaicājuma parametrus savos HTTP pieprasījumos, izmantojot Reqwest.

izmantot std:: kolekcijas:: HashMap;
izmantot reqwest::{ Kļūda, galvene};
#[tokio:: galvenais]
asinhronsfngalvenais() -> Rezultāts {
 headers_for_requests().gaidīt?;
Labi(())
}
asinhronsfnheaders_for_requests() -> Rezultāts {
// Iestatiet pieprasījuma URL un galvenes
ļaut url = " https://example.com/api";
ļautmut headers = header:: HeaderMap:: new();
 headers.insert (galvene:: USER_AGENT, galvene:: HeaderValue:: from_static("reqwest"));
 headers.insert (galvene:: CONTENT_TYPE, galvene:: HeaderValue:: from_static("aplikācija/json"));
// Iestatiet pieprasījuma vaicājuma parametrus
ļautmut params = HashMap:: new();
 params.insert("foo", "bārs");
 params.insert("baz", "qux");
// Veiciet pieprasījumu
ļaut atbilde = reqwest:: Klients:: jauns()
 .get (url)
 .headers (galvenes)
 .query(&params)
 .send()
 .gaidīt?;
// Apstrādājiet atbildi
println!("{:#?}", atbilde);
Labi(())
}

Vaicājuma parametriem tiks izveidota hashmap, ko pēc tam nosūtīsiet uz vaicājums metodi. Izveidojiet eksemplāru galvene:: HeaderMap ierakstiet, lai pievienotu galvenes.

The headers_for_requests funkcija nosūta GET pieprasījumu uz example.com ar vairākām galvenēm un vaicājuma parametriem. Tas izmanto galvenes un vaicājums metodes, kas ņem kartes, kas satur attiecīgi galvenes un vaicājuma parametrus.

Jūs varat izveidot pilnu WebApp komplektu Rust, izmantojot WASM

HTTP pieprasījumu veikšana ir ērta prasme, lai izveidotu sarežģītas lietojumprogrammas, kas integrē citu lietojumprogrammu funkcionalitāti.

Jūs varat izveidot pilnas kaudzes tīmekļa lietojumprogrammas Rust ar tādām bibliotēkām kā Percy, Yew un Sycamore, kas abstrakti sarežģīti, lai nodrošinātu izcilu izstrādes pieredzi.