HTTP-päringute tegemine roostes Reqwestiga

Nagu enamik programmeerimiskeeli, saate Rusti kasutada andmete saatmiseks ja vastuvõtmiseks HTTP kaudu. Kui loote veebipõhist teenust, peate sageli integreerima ühe või mitu teenust. Sageli saate seda teha, saates neile HTTP-päringuid.

Rustil on HTTP-toimingute jaoks sisseehitatud funktsionaalsus. Rusti ökosüsteemis on ka palju teeke, mis aitavad teil HTTP-ga suhelda ja HTTP-teenuseid luua.

HTTP-päringute tegemine rooste abil

HTTP-päringute tegemiseks on saadaval mitu Rusti teeki, sealhulgas Reqwest, Hüperja Surfata raamatukogud. Reqwest on Rusti arendajate seas kõige populaarsem.

Reqwest on kõrgetasemeline klienditeek, mis pakub lihtsat ja mugavat API-d HTTP-päringute tegemiseks. Reqwest pakub funktsioone päringute saatmiseks ning vastuste ja vigade käsitlemiseks. See võtab kokku paljud HTTP-päringu tegemise üksikasjad ja toetab täiustatud funktsioone, nagu asünkroonsed päringud, kasutades

tokio käitusaeg. Samuti käsitleb see JSON-i serialiseerimist, HTTP-päiseid, ühenduse ajalõppusid ja SSL-i sätteid.

Reqwesti teek on teile mugav, kui olete Rusti uus kasutaja või teil pole HTTP-teenustega kogemusi.

Reqwestiga alustamiseks lisage Reqwest ja Tokio raamatukogud teie projekti sõltuvustele. Tokio on asünkroonne käitusaja teek, mis töötab koos Reqwestiga. Saate need sõltuvused omale lisada Cargo.toml faili pärast Rusti projekti loomist.

[sõltuvused]
tokio = { versioon = "1.15", funktsioonid = ["täis"] }
reqwest = { versioon = "0.11", funktsioonid = ["json"] }

Kui olete Reqwesti ja Tokio teegid oma projekti sõltuvustele lisanud, installib Cargo need programmi koostamisel.

HTTP GET-päringud Reqwestiga

Veebiserverist andmete toomiseks esitate GET-päringuid. GET-päringud võivad hankida HTML-lehti, JSON-andmeid või binaarfailid, nagu pildid või videod.

Reqwest võimaldab teil määrata URL-i lõpp-punkti stringina koos päringu parameetrite ja päistega.

HTTP GET-i päringu saatmiseks URL-ile toimige järgmiselt.

kasutada reqwest:: Viga;
asünkrfnsaada_taotlus() -> Tulemus {
lase vastus = reqwest:: get(" https://www.example.com").ootama?;
println!("Olek: {}", vastus.status());
lase keha = vastus.tekst().ootama?;
println!("Keha:\n{}", keha);
Okei(())
}
#[tokio:: main]
asünkrfnpeamine() -> Tulemus {
 get_request().ootama?;
Okei(())
}

See kood määratleb asünkroonse funktsiooni, saada_taotlus, et printida aadressil example.com esitatud päringu vastuse üksikasjad. See kutsub reqwest moodulid saada meetodil ja prindib vastuse olekukood ja keha.

Siin on numbrile helistamise tulemus saada_taotlus funktsioonist peamine funktsioon:

HTTP-tõrgete käsitlemine rakendusega Reqwest

Peate käsitlema HTTP-päringute vigu, kui need tekivad. Reqwesti raamatukogu pakub Viga tüüp, mida saate vigade käsitlemiseks kasutada. Lisaks võivad veebiserveri HTTP olekukoodid anda teavet päringu oleku kohta.

Siit saate teada, kuidas saate Reqwestiga oma taotluste HTTP-vigu käsitleda.

kasutada reqwest:: Viga;
asünkrfnhand_error() -> Tulemus {
lase vastus = reqwest:: get(" https://www.example.com").ootama?;
vaste vastus.status().as_u16() {
200..=299 => {
lase keha = vastus.tekst().ootama?;
println!("Edu! Keha:\n{}", keha);
 }
400..=599 => {
lase olek = vastus.status();
lase error_message = vastus.tekst().ootama?;
println!("Viga {}: {}", olek, veateade);
 }
 _ => {
println!("Ootamatu olekukood: {}", vastus.status());
 }
 }
Okei(())
}
#[tokio:: main]
asünkrfnpeamine() -> Tulemus {
 hand_error().ootama?;
Okei(())
}

The hand_error funktsioon teeb GET päringu example.comja vaste avaldus käsitleb kõiki vigu vastuse olekukoodi alusel.

Funktsioon prindib teate ja olekukoodi sõltuvalt serverile saadetud vastusest.

HTTP POST-i päringute saatmine rakendusega Reqwest

Andmete serverisse esitamiseks esitate HTTP POST-päringuid. Seda saate teha kasutades reqwest:: Klient struktuur, mis loob kliendi ja kasutab reqwest:: RequestBuilder päringu koostamise struktuur.

Siit saate teada, kuidas saate teha POST-päringu HTTPbini POST-i päringu lõpp-punkt koos taotlusega:

kasutada reqwest::{Klient, viga};
asünkrfnPostita see() -> Tulemus {
lase url = " https://httpbin.org/post";
lase json_data = r#"{"nimi": "John Doe", "e-post": "[email protected]"}"#;
lase klient = reqwest:: Klient:: uus();
lase vastus = klient
 .post (url)
 .header("Sisu tüüp", "rakendus/json")
 .body (json_data.to_owned())
 .saada()
 .ootama?;
println!("Olek: {}", vastus.status());
lase vastuse_keha = vastus.tekst().ootama?;
println!("Vastuse sisu:\n{}", vastuse_keha);
Okei(())
}
#[tokio:: main]
asünkrfnpeamine() -> Tulemus {
 Postita see().ootama?;
Okei(())
}

The json_data muutuja määrab päringu JSON-andmed ja klient muutuja on a reqwest:: Klient näiteks POST-i päringu jaoks.

The vastuseks muutuja on POST-i päringu koostaja. The postitus meetod saadab POST-päringu URL-ile ja päis meetod määrab HTTP päise. The keha meetod määrab päringu keha ja saada meetod saadab päringu.

The Postita see funktsioon prindib vastuse olekukoodi ja keha konsooli kasutades println! makro:

HTTP-päringute päiste ja päringuparameetrite käsitlemine

Päiste ja päringuparameetrite käsitlemine on HTTP-päringute tegemise oluline aspekt. Päised sisaldavad lisateavet, nagu autentimismandaadid või taotletud sisu metaandmed.

Kasutate päringu parameetreid, et lisada URL-ile lisateavet, et server saaks vastuse filtreerida või muuta.

Päiste ja päringuparameetrite käsitlemine järgib postitaotluste saatmisega sarnast protsessi. Siit saate teada, kuidas saate Reqwestiga HTTP-päringute päiseid ja päringu parameetreid käsitleda.

kasutada std:: kogud:: HashMap;
kasutada reqwest::{ Viga, päis};
#[tokio:: main]
asünkrfnpeamine() -> Tulemus {
 headers_for_requests().ootama?;
Okei(())
}
asünkrfnheaders_for_requests() -> Tulemus {
// Seadistage päringu URL ja päised
lase url = " https://example.com/api";
lasemut headers = header:: HeaderMap:: new();
 headers.insert (päis:: USER_AGENT, päis:: HeaderValue:: from_static("reqwest"));
 headers.insert (päis:: CONTENT_TYPE, header:: HeaderValue:: from_static("rakendus/json"));
// Seadistage päringu päringu parameetrid
lasemut params = HashMap:: new();
 params.insert("foo", "baar");
 params.insert("baz", "qux");
// Esitage taotlus
lase vastus = reqwest:: Klient:: uus()
 .get (url)
 .headers (päised)
 .query(&parameetrid)
 .saada()
 .ootama?;
// Käsitlege vastust
println!("{:#?}", vastus);
Okei(())
}

Loote päringuparameetrite jaoks räsikaardi, mille seejärel edastate päring meetod. Loo eksemplar päis:: HeaderMap tippige päiste lisamiseks.

The headers_for_requests funktsioon saadab GET päringu example.com mitme päise ja päringuparameetritega. See kasutab päised ja päring meetodid, mis võtavad kaardid, mis sisaldavad vastavalt päiseid ja päringu parameetreid.

WASM-i abil saate Rust'is luua täieliku virna veebirakenduse

HTTP-päringute tegemine on oskus, mis on mugav keerukate rakenduste loomiseks, mis integreerivad teiste rakenduste funktsioone.

Saate Rustis luua täisvirna veebirakendusi selliste teekide abil nagu Percy, Yew ja Sycamore, mis abstraktsed keerukused annavad suurepärase arenduskogemuse.