HTTP-verzoeken doen in Rust met Reqwest

Zoals de meeste programmeertalen, kunt u Rust gebruiken om gegevens via HTTP te verzenden en te ontvangen. Wanneer u een webgebaseerde service bouwt, moet u vaak een of meer services integreren. U doet dit vaak door hen HTTP-verzoeken te sturen.

Rust heeft ingebouwde functionaliteit voor HTTP-bewerkingen. Er zijn ook veel bibliotheken in het Rust-ecosysteem die u helpen communiceren met HTTP en HTTP-services bouwen.

HTTP-verzoeken doen met Rust

Er zijn verschillende Rust-bibliotheken beschikbaar voor het maken van HTTP-verzoeken, waaronder de Verzoek, Hyper, En Surfen bibliotheken. Reqwest is het populairst onder Rust-ontwikkelaars.

Reqwest is een clientbibliotheek op hoog niveau die een eenvoudige en handige API biedt voor het maken van HTTP-verzoeken. Reqwest biedt functionaliteit voor het verzenden van verzoeken en het afhandelen van reacties en fouten. Het abstraheert veel details achter het maken van een HTTP-verzoek en ondersteunt geavanceerde functies zoals asynchrone verzoeken met behulp van de

Tokio looptijd. Het verwerkt ook JSON-deserialisatie, HTTP-headers, verbindingstime-outs en SSL-instellingen.

Je zult de Reqwest-bibliotheek handig vinden als je nieuw bent bij Rust of geen ervaring hebt met HTTP-services.

Om te beginnen met Reqwest, voegt u de Reqwest toe en Tokio bibliotheken aan de afhankelijkheden van uw project. Tokio is een asynchrone runtime-bibliotheek die samenwerkt met Reqwest. U kunt deze afhankelijkheden toevoegen aan uw Cargo.toml bestand na het maken van een Rust-project.

[afhankelijkheden]
Tokio = { versie = "1.15", kenmerken = ["vol"] }
verzoek = { versie = "0.11", kenmerken = ["json"] }

Nadat u de Reqwest- en Tokio-bibliotheken aan de afhankelijkheden van uw project hebt toegevoegd, zal Cargo ze installeren wanneer u uw programma bouwt.

HTTP GET-verzoeken met verzoek

U maakt GET-verzoeken om gegevens van een webserver op te halen. GET-verzoeken kunnen HTML-pagina's, JSON-gegevens of binaire bestanden zoals afbeeldingen of video's.

Met Reqwest kunt u het URL-eindpunt opgeven als een tekenreeks, samen met queryparameters en headers voor de aanvraag.

Zo kunt u een HTTP GET-verzoek naar een URL sturen:

gebruik verzoek:: Fout;
asynchroonfnkrijg_verzoek() -> Resultaat {
laten antwoord = verzoek:: get(" https://www.example.com").wachten?;
println!("Toestand: {}", reactie.status());
laten body = antwoord.tekst().wachten?;
println!("Hoofdtekst:\n{}", lichaam);
OK(())
}
#[tokio:: hoofd]
asynchroonfnvoornaamst() -> Resultaat {
 krijg_verzoek().wachten?;
OK(())
}

Deze code definieert een asynchrone functie, krijg_verzoek, om antwoorddetails van een verzoek aan example.com af te drukken. Het noemt de verzoek module's krijgen methode en drukt de de statuscode van het antwoord en lichaam.

Hier is het resultaat van het aanroepen van de krijg_verzoek functie uit de voornaamst functie:

HTTP-fouten afhandelen met Reqwest

U moet fouten van HTTP-verzoeken afhandelen wanneer deze zich voordoen. De Reqwest-bibliotheek biedt een Fout type dat u kunt gebruiken om fouten af ​​te handelen. Bovendien kunnen HTTP-statuscodes van de webserver informatie geven over de status van het verzoek.

Hier leest u hoe u HTTP-fouten voor uw verzoeken met Reqwest kunt afhandelen:

gebruik verzoek:: Fout;
asynchroonfnomgaan met fout() -> Resultaat {
laten antwoord = verzoek:: get(" https://www.example.com").wachten?;
overeenkomst reactie.status().as_u16() {
200..=299 => {
laten body = antwoord.tekst().wachten?;
println!("Succes! Tekst:\n{}", lichaam);
 }
400..=599 => {
laten status = antwoord.status();
laten error_message = antwoord.tekst().wachten?;
println!("Fout {}: {}", status, foutbericht);
 }
 _ => {
println!("Onverwachte statuscode: {}", reactie.status());
 }
 }
OK(())
}
#[tokio:: hoofd]
asynchroonfnvoornaamst() -> Resultaat {
 omgaan met fout().wachten?;
OK(())
}

De omgaan met fout functie doet een GET-verzoek aan voorbeeld.com, en de match-instructie verwerkt eventuele fouten op basis van de antwoordstatuscode.

De functie drukt een bericht en de statuscode af, afhankelijk van het antwoord op de server.

HTTP POST-verzoeken verzenden met Reqwest

U maakt HTTP POST-verzoeken om gegevens naar een server te verzenden. U kunt dit doen met behulp van de verzoek:: Klant struct die een client maakt en de verzoek:: RequestBuilder struct om het verzoek te bouwen.

Hier leest u hoe u een POST-verzoek kunt indienen bij Het eindpunt van het POST-verzoek van HTTPbin met verzoek:

gebruik reqwest::{Cliënt, Fout};
asynchroonfnpost_it() -> Resultaat {
laten URL = " https://httpbin.org/post";
laten json_data = r#"{"name": "John Doe", "email": "[email protected]"}"#;
laten klant = verzoek:: Klant:: nieuw();
laten reactie = klant
 .post (url)
 .kop("Content-Type", "toepassing/json")
 .body (json_data.to_owned())
 .versturen()
 .wachten?;
println!("Toestand: {}", reactie.status());
laten response_body = respons.tekst().wachten?;
println!("Reactietekst:\n{}", respons_body);
OK(())
}
#[tokio:: hoofd]
asynchroonfnvoornaamst() -> Resultaat {
 post_it().wachten?;
OK(())
}

De json_gegevens variabele definieert de JSON-gegevens voor het verzoek, en de cliënt variabele is een verzoek:: Klant bijvoorbeeld voor het POST-verzoek.

De antwoord variabele is de POST-aanvraagbouwer. De na methode stuurt het POST-verzoek naar de URL, en de koptekst methode stelt een HTTP-header in. De lichaam methode stelt de aanvraagtekst in, en de versturen methode stuurt het verzoek.

De post_it functie drukt de reactiestatuscode en hoofdtekst af naar de console met behulp van de println! makro:

Omgaan met headers en queryparameters Uw HTTP-verzoeken

Het afhandelen van headers en queryparameters is een belangrijk aspect van het maken van HTTP-verzoeken. Headers bevatten aanvullende informatie zoals authenticatiereferenties of metadata over de gevraagde inhoud.

U gebruikt queryparameters om aanvullende informatie aan een URL toe te voegen zodat de server een antwoord kan filteren of wijzigen.

Het afhandelen van headers en queryparameters volgt een soortgelijk proces als het verzenden van postverzoeken. Zo kunt u met Reqwest omgaan met headers en queryparameters in uw HTTP-verzoeken:

gebruik std:: verzamelingen:: HashMap;
gebruik reqwest::{ Fout, koptekst};
#[tokio:: hoofd]
asynchroonfnvoornaamst() -> Resultaat {
 headers_for_requests().wachten?;
OK(())
}
asynchroonfnheaders_for_requests() -> Resultaat {
// Stel de URL en headers in voor het verzoek
laten URL = " https://example.com/api";
latenmuts headers = header:: HeaderMap:: new();
 headers.insert (header:: USER_AGENT, header:: HeaderValue:: from_static("verzoek"));
 headers.insert (header:: CONTENT_TYPE, header:: HeaderValue:: from_static("toepassing/json"));
// Stel de queryparameters voor het verzoek in
latenmuts params = HashMap:: nieuw();
 params.insert("foe", "bar");
 params.insert("baz", "Qux");
// Doe het verzoek
laten respons = verzoek:: Klant:: nieuw()
 .get (url)
 .koppen (koppen)
 .query(&parameters)
 .versturen()
 .wachten?;
// Behandel de reactie
println!("{:#?}", antwoord);
OK(())
}

U maakt een hashmap voor de queryparameters die u vervolgens doorgeeft aan de vraag methode. Maak een instantie van de header:: HeaderMap typ om kopteksten toe te voegen.

De headers_for_requests functie stuurt een GET-verzoek naar voorbeeld.com met meerdere headers en queryparameters. Het gebruikt de koppen En vraag methoden die kaarten nemen die respectievelijk de headers en queryparameters bevatten.

U kunt een full-stack webapp bouwen in Rust met WASM

Het maken van HTTP-verzoeken is een vaardigheid die handig is voor het bouwen van geavanceerde applicaties die functionaliteit van andere applicaties integreren.

U kunt full-stack webapplicaties bouwen in Rust met bibliotheken zoals Percy, Yew en Sycamore die complexiteiten abstraheren voor een uitstekende ontwikkelervaring.