Gjør HTTP-forespørsler i rust med Reqwest

Som de fleste programmeringsspråk kan du bruke Rust til å sende og motta data over HTTP. Når du bygger en nettbasert tjeneste, må du ofte integrere en eller flere tjenester. Du vil ofte gjøre det ved å sende dem HTTP-forespørsler.

Rust har innebygd funksjonalitet for HTTP-operasjoner. Det er også mange biblioteker i Rust-økosystemet som hjelper deg med å samhandle med HTTP og bygge HTTP-tjenester.

Gjør HTTP-forespørsler med rust

Flere Rust-biblioteker er tilgjengelige for å lage HTTP-forespørsler, inkludert Reqwest, Hyper, og Surf biblioteker. Reqwest er den mest populære blant Rust-utviklere.

Reqwest er et klientbibliotek på høyt nivå som gir en enkel og praktisk API for å lage HTTP-forespørsler. Reqwest tilbyr funksjonalitet for å sende forespørsler og håndtere svar og feil. Den abstraherer mange detaljer bak å lage en HTTP-forespørsel og støtter avanserte funksjoner som asynkrone forespørsler ved å bruke

tokio kjøretid. Den håndterer også JSON-deserialisering, HTTP-hoder, tilkoblingstidsavbrudd og SSL-innstillinger.

Du vil finne Reqwest-biblioteket nyttig hvis du er ny på Rust eller mangler erfaring med HTTP-tjenester.

For å starte med Reqwest, legg til Reqwest og Tokyo biblioteker til prosjektets avhengigheter. Tokio er et asynkront kjøretidsbibliotek som samvirker med Reqwest. Du kan legge til disse avhengighetene til din Cargo.toml fil etter å ha opprettet et Rust-prosjekt.

[avhengigheter]
tokio = { versjon = "1.15", funksjoner = ["full"] }
reqwest = { versjon = "0.11", funksjoner = ["json"] }

Når du har lagt til Reqwest- og Tokio-bibliotekene til prosjektets avhengigheter, vil Cargo installere dem når du bygger programmet.

HTTP GET-forespørsler med Reqwest

Du kommer med GET-forespørsler om å hente data fra en webserver. GET-forespørsler kan hente HTML-sider, JSON-data eller binære filer som bilder eller videoer.

Reqwest lar deg spesifisere URL-endepunktet som en streng sammen med spørringsparametere og overskrifter for forespørselen.

Slik kan du sende en HTTP GET-forespørsel til en URL:

bruk reqwest:: Feil;
asynkronfnget_request() -> Resultat {
la respons = reqwest:: get(" https://www.example.com").avvente?;
println!("Status: {}", respons.status());
la body = respons.tekst().avvente?;
println!("Kroppen:\n{}", kropp);
Ok(())
}
#[tokio:: main]
asynkronfnhoved-() -> Resultat {
 get_request().avvente?;
Ok(())
}

Denne koden definerer en asynkron funksjon, get_request, for å skrive ut svardetaljer fra en forespørsel til example.com. Den kaller reqwest moduler få metode og skriver ut svarets statuskode og kropp.

Her er resultatet av å ringe get_request funksjon fra hoved- funksjon:

Håndtering av HTTP-feil med Reqwest

Du må håndtere feil fra HTTP-forespørsler når de oppstår. Reqwest-biblioteket tilbyr en Feil type som du kan bruke til å håndtere feil. I tillegg kan HTTP-statuskoder fra webserveren gi informasjon om forespørselens status.

Slik kan du håndtere HTTP-feil for forespørslene dine med Reqwest:

bruk reqwest:: Feil;
asynkronfnhandle_error() -> Resultat {
la respons = reqwest:: get(" https://www.example.com").avvente?;
kamp response.status().as_u16() {
200..=299 => {
la body = respons.tekst().avvente?;
println!("Suksess! Body:\n{}", kropp);
 }
400..=599 => {
la status = respons.status();
la error_message = respons.tekst().avvente?;
println!("Feil {}: {}", status, feilmelding);
 }
 _ => {
println!("Uventet statuskode: {}", respons.status());
 }
 }
Ok(())
}
#[tokio:: main]
asynkronfnhoved-() -> Resultat {
 handle_error().avvente?;
Ok(())
}

De handle_error funksjon gjør en GET-forespørsel til eksempel.com, og samsvarssetningen håndterer eventuelle feil basert på svarstatuskoden.

Funksjonen skriver ut en melding og statuskoden avhengig av svaret til serveren.

Sende HTTP POST-forespørsler med Reqwest

Du kommer med HTTP POST-forespørsler om å sende data til en server. Du kan gjøre det ved å bruke reqwest:: Klient struct som oppretter en klient og bruker reqwest:: RequestBuilder struktur for å bygge forespørselen.

Her er hvordan du kan sende en POST-forespørsel til HTTPbins endepunkt for POST-forespørsel med Reqwest:

bruk reqwest::{Client, Error};
asynkronfnpost_it() -> Resultat {
la url = " https://httpbin.org/post";
la json_data = r#"{"name": "John Doe", "email": "[email protected]"}"#;
la klient = reqwest:: Client:: new();
la respons = klient
 .post (nettadresse)
 .Overskrift("Innholdstype", "applikasjon/json")
 .body (json_data.to_owned())
 .sende()
 .avvente?;
println!("Status: {}", respons.status());
la response_body = respons.tekst().avvente?;
println!("Svartekst:\n{}", response_body);
Ok(())
}
#[tokio:: main]
asynkronfnhoved-() -> Resultat {
 post_it().avvente?;
Ok(())
}

De json_data variabel definerer JSON-dataene for forespørselen, og klient variabel er en reqwest:: Klient forekomst for POST-forespørselen.

De respons variabelen er POST-forespørselsbyggeren. De post metoden sender POST-forespørselen til URL-en, og Overskrift metoden setter en HTTP-header. De kropp metoden setter forespørselskroppen, og sende metoden sender forespørselen.

De post_it funksjonen skriver ut svarstatuskoden og brødteksten til konsollen ved hjelp av println! makro:

Håndtere overskrifter og spørringsparametre HTTP-forespørslene dine

Håndtering av overskrifter og spørringsparametere er et viktig aspekt ved å lage HTTP-forespørsler. Overskrifter inneholder tilleggsinformasjon som autentiseringslegitimasjon eller metadata om det forespurte innholdet.

Du bruker spørringsparametere for å legge til tilleggsinformasjon til en URL for at serveren skal filtrere eller endre et svar.

Håndtering av overskrifter og spørringsparametere følger en lignende prosess som å sende postforespørsler. Slik kan du håndtere overskrifter og spørringsparametere i HTTP-forespørslene dine med Reqwest:

bruk std:: samlinger:: HashMap;
bruk reqwest::{ Feil, header};
#[tokio:: main]
asynkronfnhoved-() -> Resultat {
 headers_for_requests().avvente?;
Ok(())
}
asynkronfnheaders_for_requests() -> Resultat {
// Sett opp URL og overskrifter for forespørselen
la url = " https://example.com/api";
lamut headers = header:: HeaderMap:: new();
 headers.insert (header:: USER_AGENT, header:: HeaderValue:: from_static("reqwest"));
 headers.insert (header:: CONTENT_TYPE, header:: HeaderValue:: from_static("applikasjon/json"));
// Sett opp spørringsparametrene for forespørselen
lamut params = HashMap:: new();
 params.insert("foo", "bar");
 params.insert("baz", "qux");
// Gjør forespørselen
la respons = reqwest:: Client:: new()
 .get (nettadresse)
 .headers (headers)
 .query(&params)
 .sende()
 .avvente?;
// Håndter svaret
println!("{:#?}", respons);
Ok(())
}

Du oppretter et hashmap for søkeparameterne som du deretter sender til spørsmål metode. Opprett en forekomst av header:: HeaderMap skriv for å legge til overskrifter.

De headers_for_requests funksjonen sender en GET-forespørsel til eksempel.com med flere overskrifter og spørringsparametere. Den bruker overskrifter og spørsmål metoder som tar kart som inneholder henholdsvis overskriftene og spørringsparametrene.

Du kan bygge Full Stack WebApp i rust med WASM

Å lage HTTP-forespørsler er en ferdighet som er nyttig for å bygge sofistikerte applikasjoner som integrerer funksjonalitet fra andre applikasjoner.

Du kan bygge fullstack webapplikasjoner i Rust med biblioteker som Percy, Yew og Sycamore som abstraherer kompleksiteten for utmerket utviklingsopplevelse.