A HTTP egy hihetetlenül népszerű módszer a távoli szerverekkel való kommunikációra. Használja ezt a kiváló Rust könyvtárat a folyamat egyszerűsítésére.

A legtöbb programozási nyelvhez hasonlóan a Rust segítségével is küldhet és fogadhat adatokat HTTP-n keresztül. Amikor webalapú szolgáltatást hoz létre, gyakran egy vagy több szolgáltatást kell integrálnia. Ezt gyakran megteheti úgy, hogy HTTP-kéréseket küld nekik.

A Rust beépített funkciókkal rendelkezik a HTTP műveletekhez. A Rust ökoszisztémában számos olyan könyvtár is található, amelyek segítenek a HTTP-vel való interakcióban és HTTP-szolgáltatások létrehozásában.

HTTP-kérések készítése Rust segítségével

Számos Rust könyvtár áll rendelkezésre HTTP-kérések készítésére, beleértve a Reqwest, Hiper, és Hullámtörés könyvtárak. A Reqwest a legnépszerűbb a Rust fejlesztők körében.

A Reqwest egy magas szintű klienskönyvtár, amely egyszerű és kényelmes API-t biztosít a HTTP-kérésekhez. A Reqwest funkciókat biztosít kérések küldésére, valamint a válaszok és hibák kezelésére. Sok részletet absztrahál a HTTP-kérés mögött, és támogatja a fejlett funkciókat, például az aszinkron kéréseket a

instagram viewer
tokio futásidő. Kezeli a JSON-deszerializálást, a HTTP-fejléceket, a csatlakozási időtúllépéseket és az SSL-beállításokat is.

A Reqwest könyvtár hasznosnak találja, ha még nem ismeri a Rustot, vagy nincs tapasztalata a HTTP szolgáltatásokkal kapcsolatban.

A Reqwest használatához adja hozzá a Reqwest és a Tokio könyvtárakat a projekt függőségeihez. A Tokio egy aszinkron futásidejű könyvtár, amely együttműködik a Reqwesttel. Ezeket a függőségeket hozzáadhatja a sajátjához Cargo.toml fájlt egy Rust projekt létrehozása után.

[függőségek]
tokio = { verzió = "1.15", funkciók = ["teljes"] }
reqwest = { verzió = "0.11", funkciók = ["json"] }

Miután hozzáadtad a Reqwest és Tokio könyvtárat a projekted függőségeihez, a Cargo telepíti őket a programod összeállításakor.

HTTP GET kérések a Reqwest segítségével

GET-kéréseket kell benyújtania az adatok webszerverről való lekéréséhez. A GET kérések HTML-oldalakat, JSON-adatokat, ill bináris fájlok, például képek vagy videók.

A Reqwest segítségével megadhatja az URL-végpontot karakterláncként a lekérdezési paraméterekkel és a kérés fejléceivel együtt.

A következőképpen küldhet HTTP GET kérést egy URL-re:

használat reqwest:: Hiba;
asyncfnget_request() -> Eredmény {
hagyja válasz = reqwest:: get(" https://www.example.com").várja?;
println!("Állapot: {}", válasz.status());


hagyja body = válasz.szöveg().várja?;
println!("törzs:\n{}", test);


Rendben(())
}
#[tokio:: fő]
asyncfnfő-() -> Eredmény {
 get_request().várja?;
Rendben(())
}

Ez a kód egy aszinkron függvényt határoz meg, get_request, hogy kinyomtassa a válasz részleteit az example.com címre érkező kérésből. Úgy hívja a reqwest modulok kap módszerrel és kiírja a válasz állapotkódja és test.

Íme a felhívás eredménye get_request funkció a fő- funkció:

HTTP-hibák kezelése a Reqwest segítségével

A HTTP-kérésekből származó hibákat akkor kell kezelnie, amikor azok felmerülnek. A Reqwest könyvtár egy Hiba típus, amelyet a hibák kezelésére használhat. Ezenkívül a webszerver HTTP-állapotkódjai információt szolgáltathatnak a kérés állapotáról.

Így kezelheti a HTTP-hibákat a Reqwest segítségével:

használat reqwest:: Hiba;
asyncfnhand_error() -> Eredmény {
hagyja válasz = reqwest:: get(" https://www.example.com").várja?;


mérkőzés válasz.status().as_u16() {
200..=299 => {
hagyja body = válasz.szöveg().várja?;
println!("Siker! Törzs:\n{}", test);
 }
400..=599 => {
hagyja status = válasz.status();
hagyja hiba_üzenet = válasz.szöveg().várja?;
println!("Hiba {}: {}", status, error_message);
 }
 _ => {
println!("Váratlan állapotkód: {}", válasz.status());
 }
 }


Rendben(())
}
#[tokio:: fő]
asyncfnfő-() -> Eredmény {
 handle_error().várja?;
Rendben(())
}

A hand_error függvény GET kérést küld a címre example.com, és a match utasítás a válasz állapotkódja alapján kezel minden hibát.

A funkció a szervernek adott választól függően üzenetet és állapotkódot nyomtat.

HTTP POST kérések küldése a Reqwest segítségével

HTTP POST kéréseket kell küldenie, hogy adatokat küldjön a szervernek. Ezt megteheti a reqwest:: Ügyfél struktúra, amely létrehoz egy klienst, és használja a reqwest:: RequestBuilder struktúra a kérés felépítéséhez.

Így küldhet POST-kérést a címre A HTTPbin POST-kérés végpontja Reqwesttel:

használat reqwest::{Client, Error};
asyncfnPosztold ki() -> Eredmény {
hagyja url = " https://httpbin.org/post";
hagyja json_data = r#"{"name": "John Doe", "e-mail": "[email protected]"}"#;


hagyja kliens = reqwest:: Kliens:: new();


hagyja válasz = ügyfél
 .post (url)
 .fejléc("Tartalom típus", "alkalmazás/json")
 .body (json_data.to_owned())
 .Küld()
 .várja?;


println!("Állapot: {}", válasz.status());


hagyja válasz_test = válasz.szöveg().várja?;
println!("Válasz törzse:\n{}", válasz_test);


Rendben(())
}
#[tokio:: fő]
asyncfnfő-() -> Eredmény {
 Posztold ki().várja?;
Rendben(())
}

A json_data változó határozza meg a kérelem JSON-adatait, és a ügyfél változó az a reqwest:: Ügyfél példány a POST kéréshez.

A válasz változó a POST kéréskészítő. A hozzászólás metódus elküldi a POST kérést az URL-re, és a fejléc metódus beállít egy HTTP-fejlécet. A test metódus beállítja a kérés törzsét, és a Küld metódus elküldi a kérést.

A Posztold ki függvény kiírja a válasz állapotkódját és törzsét a konzolra a println! makró:

Fejlécek és lekérdezési paraméterek kezelése HTTP-kérelmeihez

A fejlécek és a lekérdezési paraméterek kezelése fontos szempont a HTTP-kéréseknél. A fejlécek további információkat tartalmaznak, például hitelesítési adatokat vagy metaadatokat a kért tartalomról.

Lekérdezési paraméterek segítségével további információkat adhat hozzá az URL-hez, hogy a szerver szűrje vagy módosítsa a választ.

A fejlécek és a lekérdezési paraméterek kezelése a bejegyzéskérések küldéséhez hasonló folyamatot követ. A Reqwest segítségével a következőképpen kezelheti a fejléceket és a lekérdezési paramétereket a HTTP-kérésekben:

használat std:: gyűjtemények:: HashMap;
használat reqwest::{ Hiba, fejléc};
#[tokio:: fő]
asyncfnfő-() -> Eredmény {
 headers_for_requests().várja?;
Rendben(())
}


asyncfnheaders_for_requests() -> Eredmény {
// Állítsa be a kérés URL-címét és fejléceit
hagyja url = " https://example.com/api";
hagyjamut headers = header:: HeaderMap:: new();
 headers.insert (fejléc:: USER_AGENT, fejléc:: HeaderValue:: from_static("reqwest"));
 headers.insert (fejléc:: CONTENT_TYPE, fejléc:: HeaderValue:: from_static("alkalmazás/json"));


// Állítsa be a kérés lekérdezési paramétereit
hagyjamut params = HashMap:: new();
 params.insert("foo", "rúd");
 params.insert("baz", "qux");


// Tegye fel a kérést
hagyja válasz = reqwest:: Ügyfél:: new()
 .get (url)
 .headers (fejlécek)
 .query(&params)
 .Küld()
 .várja?;


// Kezelje a választ
println!("{:#?}", válasz);
Rendben(())
}

Létrehoz egy hashmapot a lekérdezési paraméterekhez, amelyet ezután átad a lekérdezés módszer. Hozzon létre egy példányt a fejléc:: HeaderMap írja be a fejlécek hozzáadásához.

A headers_for_requests függvény GET kérést küld a címre example.com több fejléccel és lekérdezési paraméterrel. Használja a fejlécek és lekérdezés metódusok, amelyek a fejléceket és a lekérdezési paramétereket tartalmazó térképeket veszik fel.

Full Stack WebApp-ot építhet Rustban a WASM segítségével

A HTTP-kérések elkészítése olyan készség, amely hasznos olyan kifinomult alkalmazások készítéséhez, amelyek integrálják más alkalmazások funkcionalitását.

Full-stack webalkalmazásokat készíthet Rustban olyan könyvtárakkal, mint a Percy, Yew és Sycamore, amelyek absztrakt bonyolultságokat biztosítanak a kiváló fejlesztési élmény érdekében.