HTTP-pyyntöjen tekeminen Rustissa Reqwestin avulla

Kuten useimmat ohjelmointikielet, voit käyttää Rustia tietojen lähettämiseen ja vastaanottamiseen HTTP: n kautta. Kun rakennat verkkopohjaista palvelua, sinun on usein integroitava yksi tai useampi palvelu. Teet sen usein lähettämällä heille HTTP-pyyntöjä.

Rustissa on sisäänrakennettu toiminto HTTP-toimintoja varten. Rust-ekosysteemissä on myös monia kirjastoja, jotka auttavat sinua olemaan vuorovaikutuksessa HTTP: n kanssa ja rakentamaan HTTP-palveluita.

HTTP-pyyntöjen tekeminen ruosteen avulla

Useita Rust-kirjastoja on saatavana HTTP-pyyntöjen tekemiseen, mukaan lukien Reqwest, Hyper, ja Surffaa kirjastot. Reqwest on suosituin Rust-kehittäjien keskuudessa.

Reqwest on korkean tason asiakaskirjasto, joka tarjoaa yksinkertaisen ja kätevän API: n HTTP-pyyntöjen tekemiseen. Reqwest tarjoaa toiminnot pyyntöjen lähettämiseen sekä vastausten ja virheiden käsittelyyn. Se tiivistää monia yksityiskohtia HTTP-pyynnön tekemisen takana ja tukee edistyneitä ominaisuuksia, kuten asynkronisia pyyntöjä käyttämällä

tokio suoritusaika. Se käsittelee myös JSON-sarjan poistamista, HTTP-otsikoita, yhteyden aikakatkaisuja ja SSL-asetuksia.

Reqwest-kirjasto on kätevä, jos olet uusi Rustissa tai sinulla ei ole kokemusta HTTP-palveluista.

Aloita Reqwestilla lisäämällä Reqwest ja Tokio kirjastot projektisi riippuvuuksiin. Tokio on asynkroninen ajonaikainen kirjasto, joka toimii yhdessä Reqwestin kanssa. Voit lisätä nämä riippuvuudet omaan Cargo.toml tiedosto Rust-projektin luomisen jälkeen.

[riippuvuudet]
tokio = { versio = "1.15", ominaisuuksia = ["koko"] }
reqwest = { versio = "0.11", ominaisuuksia = ["json"] }

Kun olet lisännyt Reqwest- ja Tokio-kirjastot projektisi riippuvuuksiin, Cargo asentaa ne, kun rakennat ohjelmaa.

HTTP GET -pyynnöt Reqwestillä

Teet GET-pyyntöjä tietojen hakemiseksi verkkopalvelimelta. GET-pyynnöt voivat hakea HTML-sivuja, JSON-tietoja tai binääritiedostoja, kuten kuvia tai videoita.

Reqwestin avulla voit määrittää URL-päätepisteen merkkijonona kyselyparametrien ja otsikoiden kanssa.

Näin voit lähettää HTTP GET -pyynnön URL-osoitteeseen:

käyttää reqwest:: Virhe;
asynkfnget_request() -> Tulos {
antaa vastaus = reqwest:: get(" https://www.example.com").odottaa?;
println!("Tila: {}", vastaus.tila());
antaa body = vastaus.teksti().odottaa?;
println!("Body:\n{}", runko);
Ok(())
}
#[tokio:: main]
asynkfnpää() -> Tulos {
 get_request().odottaa?;
Ok(())
}

Tämä koodi määrittelee asynkronisen funktion, get_request, tulostaaksesi vastauksen tiedot pyynnöstä osoitteeseen example.com. Se kutsuu reqwest moduulit saada menetelmällä ja tulostaa vastauksen tilakoodi ja vartalo.

Tässä on puhelun tulos get_request toiminto alkaen pää toiminto:

HTTP-virheiden käsittely Reqwestillä

Sinun on käsiteltävä HTTP-pyyntöjen virheet, kun niitä ilmenee. Reqwest-kirjasto tarjoaa Virhe tyyppi, jota voit käyttää virheiden käsittelyyn. Lisäksi web-palvelimen HTTP-tilakoodit voivat antaa tietoja pyynnön tilasta.

Näin voit käsitellä Reqwest-pyyntöjesi HTTP-virheitä:

käyttää reqwest:: Virhe;
asynkfnhand_error() -> Tulos {
antaa vastaus = reqwest:: get(" https://www.example.com").odottaa?;
ottelu vastaus.tila().as_u16() {
200..=299 => {
antaa body = vastaus.teksti().odottaa?;
println!("Menestys! Runko:\n{}", runko);
 }
400..=599 => {
antaa status = vastaus.tila();
antaa error_message = vastaus.teksti().odottaa?;
println!("Virhe {}: {}", status, error_message);
 }
 _ => {
println!("Odottamaton tilakoodi: {}", vastaus.tila());
 }
 }
Ok(())
}
#[tokio:: main]
asynkfnpää() -> Tulos {
 handle_error().odottaa?;
Ok(())
}

The hand_error toiminto tekee GET-pyynnön esimerkki.fi, ja match-lause käsittelee kaikki virheet vastauksen tilakoodin perusteella.

Toiminto tulostaa viestin ja tilakoodin riippuen vastauksesta palvelimelle.

HTTP POST -pyyntöjen lähettäminen Reqwestillä

Teet HTTP POST -pyyntöjä tietojen lähettämiseksi palvelimelle. Voit tehdä sen käyttämällä reqwest:: Asiakas rakenne, joka luo asiakkaan ja käyttää reqwest:: RequestBuilder rakenne pyynnön rakentamiseksi.

Näin voit tehdä POST-pyynnön HTTPbinin POST-pyynnön päätepiste Reqwestin kanssa:

käyttää reqwest::{Asiakas, Virhe};
asynkfnpostita se() -> Tulos {
antaa url = " https://httpbin.org/post";
antaa json_data = r#"{"nimi": "John Doe", "email": "[email protected]"}"#;
antaa client = reqwest:: Asiakas:: uusi();
antaa vastaus = asiakas
 .post (url)
 .header("Sisältötyyppi", "sovellus/json")
 .body (json_data.to_owned())
 .lähettää()
 .odottaa?;
println!("Tila: {}", vastaus.tila());
antaa vastaus_kappale = vastaus.teksti().odottaa?;
println!("Vastauksen runko:\n{}", vastaus_teksti);
Ok(())
}
#[tokio:: main]
asynkfnpää() -> Tulos {
 postita se().odottaa?;
Ok(())
}

The json_data muuttuja määrittää pyynnön JSON-tiedot ja asiakas muuttuja on a reqwest:: Asiakas esimerkki POST-pyynnölle.

The vastaus muuttuja on POST-pyyntöjen rakennusohjelma. The lähettää menetelmä lähettää POST-pyynnön URL-osoitteeseen ja otsikko menetelmä asettaa HTTP-otsikon. The kehon menetelmä asettaa pyynnön rungon ja lähettää menetelmä lähettää pyynnön.

The postita se toiminto tulostaa vastauksen tilakoodin ja rungon konsoliin käyttämällä println! makro:

HTTP-pyyntöjesi otsikoiden ja kyselyparametrien käsittely

Otsikoiden ja kyselyparametrien käsittely on tärkeä osa HTTP-pyyntöjen tekemistä. Otsikot sisältävät lisätietoja, kuten todennustiedot tai metatiedot pyydetystä sisällöstä.

Käytät kyselyparametreja lisätietojen lisäämiseen URL-osoitteeseen, jotta palvelin voi suodattaa tai muokata vastausta.

Otsikoiden ja kyselyparametrien käsittely noudattaa samanlaista prosessia kuin lähetyspyyntöjen lähettäminen. Voit käsitellä HTTP-pyyntöjesi otsikoita ja kyselyparametreja Reqwestin avulla seuraavasti:

käyttää std:: kokoelmat:: HashMap;
käyttää reqwest::{ Virhe, otsikko};
#[tokio:: main]
asynkfnpää() -> Tulos {
 headers_for_requests().odottaa?;
Ok(())
}
asynkfnheaders_for_requests() -> Tulos {
// Määritä pyynnön URL-osoite ja otsikot
antaa url = " https://example.com/api";
antaamut headers = header:: HeaderMap:: new();
 headers.insert (otsikko:: USER_AGENT, header:: HeaderValue:: from_static("reqwest"));
 headers.insert (otsikko:: CONTENT_TYPE, header:: HeaderValue:: from_static("sovellus/json"));
// Määritä kyselyn parametrit
antaamut params = HashMap:: new();
 params.insert("foo", "baari");
 params.insert("baz", "qux");
// Tee pyyntö
antaa vastaus = reqwest:: Asiakas:: uusi()
 .get (url)
 .headers (otsikot)
 .query(&params)
 .lähettää()
 .odottaa?;
// Käsittele vastaus
println!("{:#?}", vastaus);
Ok(())
}

Luot hashmapin kyselyparametreille, jotka välität sitten kysely menetelmä. Luo esiintymä header:: HeaderMap kirjoita lisätäksesi otsikot.

The headers_for_requests toiminto lähettää GET-pyynnön osoitteeseen esimerkki.fi useilla otsikoilla ja kyselyparametreilla. Se käyttää otsikot ja kysely menetelmät, jotka ottavat karttoja, jotka sisältävät otsikot ja kyselyparametrit.

Voit rakentaa Full Stack WebApp -sovelluksen Rustiin WASM: n avulla

HTTP-pyyntöjen tekeminen on taito, joka on kätevä kehitettäessä kehittyneitä sovelluksia, jotka yhdistävät toimintoja muista sovelluksista.

Voit rakentaa täyden pinon verkkosovelluksia Rustissa Percyn, Yewn ja Sycamoren kaltaisten kirjastojen avulla, jotka abstraktit monimutkaisuudet takaavat erinomaisen kehityskokemuksen.