Gör HTTP-förfrågningar i Rust med Reqwest

Som de flesta programmeringsspråk kan du använda Rust för att skicka och ta emot data över HTTP. När du bygger en webbaserad tjänst behöver du ofta integrera en eller flera tjänster. Du kommer ofta att göra det genom att skicka HTTP-förfrågningar till dem.

Rust har inbyggd funktionalitet för HTTP-operationer. Det finns också många bibliotek i Rust-ekosystemet som hjälper dig att interagera med HTTP och bygga HTTP-tjänster.

Gör HTTP-förfrågningar med rost

Flera Rust-bibliotek är tillgängliga för att göra HTTP-förfrågningar, inklusive Reqwest, Hyper, och Surfa bibliotek. Reqwest är den mest populära bland Rust-utvecklare.

Reqwest är ett klientbibliotek på hög nivå som tillhandahåller ett enkelt och bekvämt API för att göra HTTP-förfrågningar. Reqwest tillhandahåller funktionalitet för att skicka förfrågningar och hantera svar och fel. Den sammanfattar många detaljer bakom att göra en HTTP-förfrågan och stöder avancerade funktioner som asynkrona förfrågningar med hjälp av

tokio körning. Den hanterar också JSON-deserialisering, HTTP-rubriker, anslutningstidsgränser och SSL-inställningar.

Du kommer att hitta Reqwest-biblioteket praktiskt om du är ny på Rust eller saknar erfarenhet av HTTP-tjänster.

För att börja med Reqwest, lägg till Reqwest och Tokyo bibliotek till ditt projekts beroenden. Tokio är ett asynkront runtime-bibliotek som samverkar med Reqwest. Du kan lägga till dessa beroenden till din Cargo.toml fil efter att ha skapat ett Rust-projekt.

[beroenden]
tokio = { version = "1.15", funktioner = ["full"] }
reqwest = { version = "0.11", funktioner = ["json"] }

När du har lagt till Reqwest- och Tokio-biblioteken till ditt projekts beroenden kommer Cargo att installera dem när du bygger ditt program.

HTTP GET-förfrågningar med Reqwest

Du kommer att göra GET-förfrågningar för att hämta data från en webbserver. GET-förfrågningar kan hämta HTML-sidor, JSON-data eller binära filer som bilder eller videor.

Reqwest låter dig ange URL-slutpunkten som en sträng tillsammans med frågeparametrar och rubriker för begäran.

Så här kan du skicka en HTTP GET-förfrågan till en URL:

använda sig av reqwest:: Fel;
asynkronfnget_request() -> Resultat {
låta svar = reqwest:: get(" https://www.example.com").vänta?;
println!("Status: {}", response.status());
låta body = response.text().vänta?;
println!("Kroppen:\n{}"kropp);
Ok(())
}
#[tokio:: main]
asynkronfnhuvud() -> Resultat {
 get_request().vänta?;
Ok(())
}

Denna kod definierar en asynkron funktion, get_request, för att skriva ut svarsdetaljer från en förfrågan till example.com. Den kallar reqwest modulens skaffa sig metod och skriver ut svarets statuskod och kropp.

Här är resultatet av att ringa till get_request funktion från huvud fungera:

Hantera HTTP-fel med Reqwest

Du måste hantera fel från HTTP-förfrågningar när de uppstår. Reqwest-biblioteket tillhandahåller en Fel typ som du kan använda för att hantera fel. Dessutom kan HTTP-statuskoder från webbservern ge information om begärans status.

Så här kan du hantera HTTP-fel för dina förfrågningar med Reqwest:

använda sig av reqwest:: Fel;
asynkronfnhandle_error() -> Resultat {
låta svar = reqwest:: get(" https://www.example.com").vänta?;
match response.status().as_u16() {
200..=299 => {
låta body = response.text().vänta?;
println!("Framgång! Kropp:\n{}"kropp);
 }
400..=599 => {
låta status = respons.status();
låta error_message = response.text().vänta?;
println!("Fel {}: {}", status, felmeddelande);
 }
 _ => {
println!("Oväntad statuskod: {}", response.status());
 }
 }
Ok(())
}
#[tokio:: main]
asynkronfnhuvud() -> Resultat {
 handle_error().vänta?;
Ok(())
}

De handle_error funktionen gör en GET-förfrågan till exempel.com, och matchsatsen hanterar eventuella fel baserat på svarsstatuskoden.

Funktionen skriver ut ett meddelande och statuskoden beroende på svaret till servern.

Skicka HTTP POST-förfrågningar med Reqwest

Du kommer att göra HTTP POST-förfrågningar för att skicka data till en server. Du kan göra det med hjälp av reqwest:: Kund struct som skapar en klient och använder reqwest:: RequestBuilder struct för att skapa begäran.

Så här kan du göra en POST-förfrågan till HTTPbins POST-begäranslutpunkt med Reqwest:

använda sig av reqwest::{Client, Error};
asynkronfnposta det() -> Resultat {
låta url = " https://httpbin.org/post";
låta json_data = r#"{"name": "John Doe", "email": "[email protected]"}"#;
låta client = reqwest:: Client:: new();
låta svar = klient
 .post (url)
 .rubrik("Innehållstyp", "applikation/json")
 .body (json_data.to_owned())
 .skicka()
 .vänta?;
println!("Status: {}", response.status());
låta response_body = response.text().vänta?;
println!("Svarstext:\n{}", response_body);
Ok(())
}
#[tokio:: main]
asynkronfnhuvud() -> Resultat {
 posta det().vänta?;
Ok(())
}

De json_data variabeln definierar JSON-data för begäran och klient variabel är a reqwest:: Kund instans för POST-begäran.

De svar variabeln är POST-förfrågningsbyggaren. De posta metoden skickar POST-begäran till URL: en och rubrik metod ställer in en HTTP-rubrik. De kropp metoden ställer in förfrågningskroppen och skicka metod skickar begäran.

De posta det funktionen skriver ut svarsstatuskoden och texten till konsolen med hjälp av println! makro:

Hantera rubriker och frågeparametrar Dina HTTP-förfrågningar

Att hantera rubriker och frågeparametrar är en viktig aspekt av att göra HTTP-förfrågningar. Rubriker innehåller ytterligare information som autentiseringsuppgifter eller metadata om det begärda innehållet.

Du kommer att använda frågeparametrar för att lägga till ytterligare information till en URL för servern att filtrera eller ändra ett svar.

Hantering av rubriker och frågeparametrar följer en liknande process som att skicka inläggsbegäranden. Så här kan du hantera rubriker och frågeparametrar i dina HTTP-förfrågningar med Reqwest:

använda sig av std:: samlingar:: HashMap;
använda sig av reqwest::{ Error, header};
#[tokio:: main]
asynkronfnhuvud() -> Resultat {
 headers_for_requests().vänta?;
Ok(())
}
asynkronfnheaders_for_requests() -> Resultat {
// Ställ in URL och rubriker för begäran
låta url = " https://example.com/api";
låtamut headers = header:: HeaderMap:: new();
 headers.insert (header:: USER_AGENT, header:: HeaderValue:: from_static("reqwest"));
 headers.insert (header:: CONTENT_TYPE, header:: HeaderValue:: from_static("applikation/json"));
// Ställ in frågeparametrarna för begäran
låtamut params = HashMap:: new();
 params.insert("foo", "bar");
 params.insert("baz", "qux");
// Gör begäran
låta svar = reqwest:: Client:: new()
 .get (url)
 .headers (headers)
 .query(&params)
 .skicka()
 .vänta?;
// Hantera svaret
println!("{:#?}", svar);
Ok(())
}

Du skapar en hashmap för frågeparametrarna som du sedan skickar till fråga metod. Skapa en instans av header:: HeaderMap skriv för att lägga till rubriker.

De headers_for_requests funktionen skickar en GET-förfrågan till exempel.com med flera rubriker och frågeparametrar. Den använder rubriker och fråga metoder som tar kartor som innehåller rubrikerna respektive frågeparametrarna.

Du kan bygga Full Stack WebApp i Rust med WASM

Att göra HTTP-förfrågningar är en färdighet som är praktisk för att bygga sofistikerade applikationer som integrerar funktionalitet från andra applikationer.

Du kan bygga full-stack webbapplikationer i Rust med bibliotek som Percy, Yew och Sycamore som abstraherar komplexiteten för utmärkt utvecklingsupplevelse.