Efectuarea de solicitări HTTP în Rust cu Reqwest

La fel ca majoritatea limbajelor de programare, puteți folosi Rust pentru a trimite și primi date prin HTTP. Când construiți un serviciu bazat pe web, va trebui adesea să integrați unul sau mai multe servicii. Veți face adesea acest lucru trimițându-le solicitări HTTP.

Rust are o funcționalitate încorporată pentru operațiuni HTTP. Există, de asemenea, multe biblioteci în ecosistemul Rust care vă ajută să interacționați cu HTTP și să construiți servicii HTTP.

Efectuarea de solicitări HTTP cu Rust

Mai multe biblioteci Rust sunt disponibile pentru a face cereri HTTP, inclusiv Reqwest, Hiper, și Surf biblioteci. Reqwest este cel mai popular printre dezvoltatorii Rust.

Reqwest este o bibliotecă client de nivel înalt care oferă un API simplu și convenabil pentru a face solicitări HTTP. Reqwest oferă funcționalitate pentru trimiterea cererilor și gestionarea răspunsurilor și erorilor. Abstrage multe detalii din spatele efectuării unei solicitări HTTP și acceptă funcții avansate, cum ar fi solicitările asincrone folosind

tokio timpul de rulare. De asemenea, se ocupă de deserializarea JSON, anteturile HTTP, expirarea timpului de conexiune și setările SSL.

Veți găsi biblioteca Reqwest la îndemână dacă sunteți nou la Rust sau nu aveți experiență cu serviciile HTTP.

Pentru a începe cu Reqwest, adăugați Reqwest și Tokio biblioteci la dependențele proiectului dvs. Tokio este o bibliotecă de rulare asincronă care interoperează cu Reqwest. Puteți adăuga aceste dependențe la dvs Marfă.toml fișier după crearea unui proiect Rust.

[dependențe]
tokio = { versiunea = "1.15", caracteristici = ["deplin"] }
reqwest = { versiunea = "0.11", caracteristici = ["json"] }

După ce ați adăugat bibliotecile Reqwest și Tokio la dependențele proiectului dvs., Cargo le va instala atunci când vă construiți programul.

Solicitări HTTP GET cu Reqwest

Veți face solicitări GET pentru a prelua date de pe un server web. Solicitările GET pot prelua pagini HTML, date JSON sau fișiere binare, cum ar fi imagini sau videoclipuri.

Reqwest vă permite să specificați punctul final al URL-ului ca șir împreună cu parametrii de interogare și anteturile cererii.

Iată cum puteți trimite o solicitare HTTP GET la o adresă URL:

utilizare reqwest:: Eroare;
asincronfnget_request() -> Rezultat {
lăsa raspuns = solicitat:: get(" https://www.example.com").așteaptă?;
println!("Stare: {}", response.status());
lăsa body = răspuns.text().așteaptă?;
println!(„Corpul:\n{}”, corp);
Bine(())
}
#[tokio:: principal]
asincronfnprincipal() -> Rezultat {
 get_request().așteaptă?;
Bine(())
}

Acest cod definește o funcție asincronă, get_request, pentru a imprima detaliile răspunsului dintr-o solicitare către example.com. Se numeste reqwest modulelor obține metoda și imprimă codul de stare al răspunsului si trupul.

Iată rezultatul apelării la get_request funcția de la principal funcţie:

Gestionarea erorilor HTTP cu Reqwest

Va trebui să gestionați erorile de la solicitările HTTP atunci când apar. Biblioteca Reqwest oferă un Eroare tip pe care îl puteți folosi pentru a gestiona erorile. În plus, codurile de stare HTTP de la serverul web pot oferi informații despre starea solicitării.

Iată cum puteți gestiona erorile HTTP pentru solicitările dvs. cu Reqwest:

utilizare reqwest:: Eroare;
asincronfnhandle_error() -> Rezultat {
lăsa raspuns = solicitat:: get(" https://www.example.com").așteaptă?;
Meci răspuns.status().as_u16() {
200..=299 => {
lăsa body = răspuns.text().așteaptă?;
println!("Succes! Corp:\n{}", corp);
 }
400..=599 => {
lăsa status = response.status();
lăsa mesaj_eroare = răspuns.text().așteaptă?;
println!(„Eroare {}: {}”, stare, mesaj_eroare);
 }
 _ => {
println!(„Cod de stare neașteptat: {}”, response.status());
 }
 }
Bine(())
}
#[tokio:: principal]
asincronfnprincipal() -> Rezultat {
 handle_error().așteaptă?;
Bine(())
}

The handle_error funcția face o solicitare GET către exemplu.com, iar instrucțiunea de potrivire tratează orice erori pe baza codului de stare a răspunsului.

Funcția imprimă un mesaj și codul de stare în funcție de răspunsul la server.

Trimiterea solicitărilor HTTP POST cu Reqwest

Veți face solicitări HTTP POST pentru a trimite date către un server. Puteți face acest lucru folosind reqwest:: Client struct care creează un client și utilizează reqwest:: RequestBuilder struct pentru a construi cererea.

Iată cum puteți face o solicitare POST către Punctul final al solicitării POST al HTTPbin cu Reqwest:

utilizare reqwest::{Client, Eroare};
asincronfnpostează() -> Rezultat {
lăsa url = " https://httpbin.org/post";
lăsa json_data = r#"{"nume": "John Doe", "email": "[email protected]"}"#;
lăsa client = reqwest:: Client:: new();
lăsa răspuns = client
 .post (url)
 .antet("Tipul de conținut", "aplicație/json")
 .body (json_data.to_owned())
 .trimite()
 .așteaptă?;
println!("Stare: {}", response.status());
lăsa răspuns_corp = răspuns.text().așteaptă?;
println!(„Corpul răspunsului:\n{}”, răspuns_corp);
Bine(())
}
#[tokio:: principal]
asincronfnprincipal() -> Rezultat {
 postează().așteaptă?;
Bine(())
}

The json_data variabila definește datele JSON pentru cerere și client variabila este a reqwest:: Client exemplu pentru cererea POST.

The raspuns variabila este generatorul de cereri POST. The post metoda trimite cererea POST la adresa URL și antet metoda setează un antet HTTP. The corp metoda setează corpul cererii și trimite metoda trimite cererea.

The postează funcția imprimă codul de stare a răspunsului și corpul pe consolă folosind println! macro:

Gestionarea antetelor și a parametrilor de interogare solicitările dvs. HTTP

Gestionarea antetelor și a parametrilor de interogare este un aspect important al efectuării solicitărilor HTTP. Anteturile conțin informații suplimentare, cum ar fi acreditările de autentificare sau metadate despre conținutul solicitat.

Veți folosi parametrii de interogare pentru a adăuga informații suplimentare la o adresă URL pentru ca serverul să filtreze sau să modifice un răspuns.

Gestionarea antetelor și a parametrilor de interogare urmează un proces similar cu trimiterea solicitărilor de postare. Iată cum puteți gestiona anteturile și parametrii de interogare în solicitările dvs. HTTP cu Reqwest:

utilizare std:: colecții:: HashMap;
utilizare reqwest::{ Eroare, antet};
#[tokio:: principal]
asincronfnprincipal() -> Rezultat {
 headers_for_requests().așteaptă?;
Bine(())
}
asincronfnheaders_for_requests() -> Rezultat {
// Configurați adresa URL și anteturile pentru cerere
lăsa url = " https://example.com/api";
lăsamut headers = header:: HeaderMap:: new();
 headers.insert (header:: USER_AGENT, header:: HeaderValue:: from_static("cerere"));
 headers.insert (header:: CONTENT_TYPE, header:: HeaderValue:: from_static("aplicație/json"));
// Configurați parametrii de interogare pentru cerere
lăsamut parametri = HashMap:: new();
 params.insert("foo", "bar");
 params.insert("baz", "qux");
// Faceți cererea
lăsa răspuns = reqwest:: Client:: nou()
 .get (url)
 .headers (anteturi)
 .query(&params)
 .trimite()
 .așteaptă?;
// Gestionează răspunsul
println!("{:#?}", raspuns);
Bine(())
}

Veți crea o hartă hash pentru parametrii de interogare pe care apoi îi veți transmite interogare metodă. Creați o instanță a header:: HeaderMap tastați pentru a adăuga anteturi.

The headers_for_requests funcția trimite o solicitare GET către exemplu.com cu mai multe antete și parametri de interogare. Acesta folosește antete și interogare metode care preiau hărți care conțin antetele și, respectiv, parametrii de interogare.

Puteți construi aplicații web Full Stack în Rust cu WASM

Efectuarea de solicitări HTTP este o abilitate utilă pentru construirea de aplicații sofisticate care integrează funcționalități din alte aplicații.

Puteți construi aplicații web full-stack în Rust cu biblioteci precum Percy, Yew și Sycamore care abstractizează complexitățile pentru o experiență excelentă de dezvoltare.