HTTP è un metodo incredibilmente popolare per comunicare con i server remoti. Usa questa eccellente libreria Rust per semplificare il processo.

Come la maggior parte dei linguaggi di programmazione, puoi utilizzare Rust per inviare e ricevere dati tramite HTTP. Quando crei un servizio basato sul Web, spesso dovrai integrare uno o più servizi. Lo farai spesso inviando loro richieste HTTP.

Rust ha funzionalità integrate per le operazioni HTTP. Ci sono anche molte librerie nell'ecosistema Rust che ti aiutano a interagire con HTTP e creare servizi HTTP.

Effettuare richieste HTTP con Rust

Sono disponibili diverse librerie Rust per effettuare richieste HTTP, incluso il Richiesto, Iper, E Surf biblioteche. Reqwest è il più popolare tra gli sviluppatori di Rust.

Reqwest è una libreria client di alto livello che fornisce un'API semplice e conveniente per effettuare richieste HTTP. Reqwest fornisce funzionalità per l'invio di richieste e la gestione di risposte ed errori. Astrae molti dettagli dietro l'effettuazione di una richiesta HTTP e supporta funzionalità avanzate come le richieste asincrone utilizzando il

instagram viewer
tokio tempo di esecuzione. Gestisce anche la deserializzazione JSON, le intestazioni HTTP, i timeout di connessione e le impostazioni SSL.

Troverai utile la libreria Reqwest se non conosci Rust o non hai esperienza con i servizi HTTP.

Per iniziare con Reqwest, aggiungi Reqwest e Tokyo librerie alle dipendenze del tuo progetto. Tokio è una libreria runtime asincrona che interagisce con Reqwest. Puoi aggiungere queste dipendenze al tuo file Cargo.toml file dopo aver creato un progetto Rust.

[dipendenze]
tokio = { versione = "1.15", caratteristiche = ["pieno"] }
reqwest = { versione = "0.11", caratteristiche = ["json"] }

Dopo aver aggiunto le librerie Reqwest e Tokio alle dipendenze del tuo progetto, Cargo le installerà quando costruirai il tuo programma.

Richieste HTTP GET con Reqwest

Farai richieste GET per recuperare i dati da un server web. Le richieste GET possono recuperare pagine HTML, dati JSON o file binari come immagini o video.

Reqwest ti consente di specificare l'endpoint dell'URL come stringa insieme ai parametri di query e alle intestazioni per la richiesta.

Ecco come inviare una richiesta HTTP GET a un URL:

utilizzo reqwest:: Errore;
asincronofnget_request() -> Risultato {
permettere risposta = reqwest:: get(" https://www.example.com").aspetta?;
stampa!("Stato: {}", risposta.stato());


permettere corpo = risposta.testo().aspetta?;
stampa!("Corpo:\n{}", corpo);


OK(())
}
#[tokio:: principale]
asincronofnprincipale() -> Risultato {
 get_request().aspetta?;
OK(())
}

Questo codice definisce una funzione asincrona, get_request, per stampare i dettagli della risposta da una richiesta a example.com. Chiama il reqwest del modulo Ottenere metodo e stampa il file codice di stato della risposta e corpo.

Ecco il risultato della chiamata al get_request funzione dal principale funzione:

Gestione degli errori HTTP con Reqwest

Dovrai gestire gli errori delle richieste HTTP quando si presentano. La libreria Reqwest fornisce un file Errore type che è possibile utilizzare per gestire gli errori. Inoltre, i codici di stato HTTP dal server Web possono fornire informazioni sullo stato della richiesta.

Ecco come puoi gestire gli errori HTTP per le tue richieste con Reqwest:

utilizzo reqwest:: Errore;
asincronofnhandle_error() -> Risultato {
permettere risposta = reqwest:: get(" https://www.example.com").aspetta?;


incontro risposta.stato().as_u16() {
200..=299 => {
permettere corpo = risposta.testo().aspetta?;
stampa!("Successo! Corpo:\n{}", corpo);
 }
400..=599 => {
permettere stato = risposta.stato();
permettere messaggio_errore = risposta.testo().aspetta?;
stampa!("Errore {}: {}", stato, messaggio_errore);
 }
 _ => {
stampa!("Codice di stato imprevisto: {}", risposta.stato());
 }
 }


OK(())
}
#[tokio:: principale]
asincronofnprincipale() -> Risultato {
 handle_error().aspetta?;
OK(())
}

IL handle_error la funzione effettua una richiesta GET a esempio.come l'istruzione match gestisce eventuali errori in base al codice di stato della risposta.

La funzione stampa un messaggio e il codice di stato in base alla risposta al server.

Invio di richieste HTTP POST con Reqwest

Farai richieste HTTP POST per inviare dati a un server. Puoi farlo usando il reqwest:: Cliente struct che crea un client e utilizza il file reqwest:: RequestBuilder struct per creare la richiesta.

Ecco come puoi fare una richiesta POST a Endpoint della richiesta POST di HTTPbin con Reqwest:

utilizzo reqwest::{Cliente, errore};
asincronofnpubblicalo() -> Risultato {
permettere URL = " https://httpbin.org/post";
permettere json_data = r#"{"name": "John Doe", "email": "[email protected]"}"#;


permettere client = reqwest:: Client:: new();


permettere risposta = cliente
 .post (url)
 .intestazione("Tipo di contenuto", "applicazione/json")
 .body (json_data.to_owned())
 .Inviare()
 .aspetta?;


stampa!("Stato: {}", risposta.stato());


permettere risposta_corpo = risposta.testo().aspetta?;
stampa!("Corpo della risposta:\n{}", risposta_corpo);


OK(())
}
#[tokio:: principale]
asincronofnprincipale() -> Risultato {
 pubblicalo().aspetta?;
OK(())
}

IL json_data La variabile definisce i dati JSON per la richiesta e la cliente variabile è a reqwest:: Cliente istanza per la richiesta POST.

IL risposta variabile è il generatore di richieste POST. IL inviare Il metodo invia la richiesta POST all'URL e il intestazione metodo imposta un'intestazione HTTP. IL corpo metodo imposta il corpo della richiesta e il Inviare metodo invia la richiesta.

IL pubblicalo La funzione stampa il codice di stato e il corpo della risposta sulla console utilizzando il stampa! macro:

Gestione di intestazioni e parametri di query Le tue richieste HTTP

La gestione delle intestazioni e dei parametri di query è un aspetto importante delle richieste HTTP. Le intestazioni contengono informazioni aggiuntive come credenziali di autenticazione o metadati sul contenuto richiesto.

Utilizzerai i parametri di query per aggiungere ulteriori informazioni a un URL affinché il server filtri o modifichi una risposta.

La gestione delle intestazioni e dei parametri di query segue un processo simile all'invio di richieste di post. Ecco come puoi gestire intestazioni e parametri di query nelle tue richieste HTTP con Reqwest:

utilizzo std:: collezioni:: HashMap;
utilizzo reqwest::{ Errore, intestazione};
#[tokio:: principale]
asincronofnprincipale() -> Risultato {
 headers_for_requests().aspetta?;
OK(())
}


asincronofnheaders_for_requests() -> Risultato {
// Imposta l'URL e le intestazioni per la richiesta
permettere URL = " https://example.com/api";
permetteremut headers = header:: HeaderMap:: new();
 headers.insert (header:: USER_AGENT, header:: HeaderValue:: from_static("richiesto"));
 headers.insert (header:: CONTENT_TYPE, header:: HeaderValue:: from_static("applicazione/json"));


// Imposta i parametri della query per la richiesta
permetteremut params = HashMap:: new();
 params.insert("pippo", "sbarra");
 params.insert("bazz", "qux");


// Fai la richiesta
permettere risposta = reqwest:: Cliente:: new()
 .get (URL)
 .headers (intestazioni)
 .query(&parametri)
 .Inviare()
 .aspetta?;


// Gestisci la risposta
stampa!("{:#?}", risposta);
OK(())
}

Creerai una hashmap per i parametri della query che poi passerai al domanda metodo. Crea un'istanza di header:: HeaderMap digitare per aggiungere intestazioni.

IL headers_for_requests la funzione invia una richiesta GET a esempio.com con più intestazioni e parametri di query. Utilizza il intestazioni E domanda metodi che accettano mappe contenenti rispettivamente le intestazioni e i parametri di query.

Puoi creare un'app Web full stack in Rust con WASM

Effettuare richieste HTTP è un'abilità utile per creare applicazioni sofisticate che integrano funzionalità di altre applicazioni.

Puoi creare applicazioni web full-stack in Rust con librerie come Percy, Yew e Sycamore che astraggono le complessità per un'esperienza di sviluppo eccellente.