Come effettuare richieste HTTP in Go

Uno dei principi fondamentali che regolano il funzionamento del World Wide Web è lo scambio di richieste e risposte. Quando invii una richiesta di accesso a una pagina web, il server risponde con i dati appropriati.

I protocolli popolari che regolano diversi tipi di comunicazione Internet includono http (protocollo di trasferimento ipertestuale), FTP (protocollo di trasferimento file) e SMTP (protocollo di trasferimento di posta semplice).

HTTP è il protocollo che utilizzerai in genere quando visualizzi un sito Web o utilizzi un'app abilitata per il Web. Puoi anche lavorare con richieste HTTP da molti linguaggi di programmazione, incluso Go.

Che cos'è una richiesta HTTP?

HTTP definisce il modo in cui i client, come i browser Web, inviano richieste ai server che poi restituiscono una risposta. Una richiesta HTTP contiene informazioni su una risorsa a cui il client sta tentando di accedere. Il messaggio di richiesta in genere comprende un URL che identifica la risorsa e altri dati facoltativi come intestazioni e parametri di query.

Ci sono diversi tipi di richiesta HTTP, inclusi GET, POST, PUT, DELETE, HEAD, OPTIONS e CONNECT. I primi quattro tipi di metodo sono i più comuni; rispecchiano rispettivamente le operazioni CRUD di lettura, creazione, aggiornamento ed eliminazione.

Il tipo di richiesta PUT viene spesso utilizzato in modo intercambiabile con il tipo di richiesta PATCH. Raggiungono lo stesso scopo, differiscono solo per i dati che si aspettano che la richiesta includa.

Invio di richieste tramite metodi HTTP comuni

Go è integrato http pacchetto fornisce una serie di funzioni e strutture utilizzabili per creare server Web e gestire le richieste HTTP. È un pacchetto molto robusto e tutti i framework web Go si basano su di esso in un modo o nell'altro. È un sottopacchetto di Go's netto pacchetto.

Per creare una richiesta HTTP in Go, puoi utilizzare il file http. Nuova richiesta() funzione e impostare il metodo, l'URL, le intestazioni e il corpo della richiesta appropriati. Dopo aver creato la richiesta, puoi utilizzare il metodo Go rete/http Pacchetti http. Cliente{} struttura per eseguirlo e ricevere la risposta.

I seguenti esempi di codice usano reqre.in, un'API pubblicamente disponibile per testare le richieste HTTP. Puoi usarlo per testare le richieste GET, POST, PUT e DELETE nei tuoi programmi Go.

POST Richiesta

Il codice seguente è una funzione che invia una richiesta POST al /api/users endpoint di reqres.in per creare un nuovo utente con un nome e un lavoro.

pacchetto principale
importare (
"byte"
"codifica/json"
"fmt"
"io"
"rete/http"
)
funzcreare un utente(nome, lavoro corda) {
 fmt. Stampaln("Creazione utente...")
 apiUrl := " https://reqres.in/api/users"
 dati utente := []byte(`{"nome":"` + nome + `","lavoro":"` + lavoro + `"}`)
// crea una nuova richiesta http
 richiesta, errore := http. Nuova richiesta("INVIARE", apiUrl, byte. NuovoBuffer (dati utente))
 richiesta. Intestazione. Impostato("Tipo di contenuto", "applicazione/json; set di caratteri=utf-8")
// invia la richiesta
 cliente := &http. Cliente{}
 risposta, errore := client. Fare (richiesta)
Se errore != zero {
 fmt. Println (errore)
 }
 responseBody, errore := io. LeggiTutto (risposta. Corpo)
Se errore != zero {
 fmt. Println (errore)
 }
 formattedData := formatJSON(responseBody)
 fmt. Stampaln("Stato: ", risposta. Stato)
 fmt. Stampaln("Corpo di risposta: ", formattedData)
// pulisce la memoria dopo l'esecuzione
differire risposta. Corpo. Vicino()
}

formatJSON è una funzione personalizzata che puoi scrivere per formattare i dati di output. Ecco come puoi implementarlo:

// funzione per formattare i dati JSON
funzformatJSON(dati []byte)corda {
var fuori byte. Respingente
 err := json. Rientro(&fuori, dati, "", " ")
Se errare!= zero {
 fmt. Stampaln (err)
 }
 d := fuori. Byte()
ritornocorda(D)
}

Puoi chiamare il creare un utente() funzione in un programma come questo:

funzprincipale() {
 fmt. Stampaln("Fare richiesta POST...")
 creare un utente("Tim Omolana", "Scrittore")
}

Quando si esegue il programma in un terminale, utilizzando il file vai a correre comando, vedrai un output come questo:

OTTIENI Richiesta

Il codice seguente è una funzione che invia una richiesta GET per recuperare un utente dal server reqres.in utilizzando il suo ID univoco.

// main.go
funzgetUser(id corda) {
 fmt. Stampaln("Ottieni utente per ID...")
// effettua una richiesta GET all'API per ottenere l'utente per ID
 apiUrl := " https://reqres.in/api/users/" + id
 richiesta, errore := http. Nuova richiesta("OTTENERE", apiUrl, zero)
Se errore != zero {
 fmt. Println (errore)
 }
 richiesta. Intestazione. Impostato("Tipo di contenuto", "applicazione/json; set di caratteri=utf-8")
 cliente := &http. Cliente{}
 risposta, errore := client. Fare (richiesta)
Se errore != zero {
 fmt. Println (errore)
 }
 responseBody, errore := io. LeggiTutto (risposta. Corpo)
Se errore != zero {
 fmt. Println (errore)
 }
 formattedData := formatJSON(responseBody)
 fmt. Stampaln("Stato: ", risposta. Stato)
 fmt. Stampaln("Corpo di risposta: ", formattedData)
// pulisce la memoria dopo l'esecuzione
differire risposta. Corpo. Vicino()
}

Una richiesta GET non invia dati al server, quindi non accetta o invia il corpo della richiesta al server quando viene effettuata. Ecco come apparirà una chiamata di esempio alla funzione sopra:

funzprincipale() {
 fmt. Stampaln("Fare richiesta GET...")
 getUser("2")
}

Produzione:

Richiesta PUT

La richiesta PUT è molto simile a una richiesta POST perché invia anche dati al server. La differenza principale è che POST crea una nuova risorsa mentre PUT ne aggiorna una esistente.

Ecco un'implementazione di una richiesta PUT:

// main.go
funzupdateUser(nome, lavoro, id corda) {
 fmt. Stampaln("Aggiornamento utente...")
// effettua una richiesta PUT all'API per aggiornare l'utente
 apiUrl := " https://reqres.in/api/users/" + id
 dati utente := []byte(`{"nome":"` + nome + `","lavoro":"` + lavoro + `"}`)
// crea una nuova richiesta http PUT
 richiesta, errore := http. Nuova richiesta("METTERE", apiUrl, byte. NuovoBuffer (dati utente))
 richiesta. Intestazione. Impostato("Tipo di contenuto", "applicazione/json; set di caratteri=utf-8")
// Corpo della funzione rimanente dalla funzione createUser...
// Fai una richiesta, ricevi una risposta e cancella la memoria...
}

Da questo codice, puoi vedere le uniche differenze tra la richiesta PUT e la richiesta POST sopra sono il nome del metodo e l'URL. Quando utilizzi un PUT per aggiornare i dati esistenti, dovrai aggiungere l'ID all'URL della richiesta. Una chiamata di esempio a questa funzione sarebbe simile a questa:

funzione principale() {
// aggiorna la voce con l'ID 2.
 aggiornautente("Tim Newname", "Scrittore personale", "2")
}

Il codice precedente aggiorna l'utente e produce il seguente output:

ELIMINA Richiesta

Utilizzare il metodo di richiesta DELETE per eseguire un'operazione di eliminazione su un server Web. Una richiesta di eliminazione elimina la risorsa identificata dall'URI. Una richiesta DELETE in Go ha il seguente aspetto:

funzdeleteUser(id corda) {
 fmt. Stampaln("Cancellazione utente...")
// effettua una richiesta DELETE all'API per eliminare l'utente
 apiUrl := " https://reqres.in/api/users/" + id
// crea una nuova richiesta http
 richiesta, errore := http. Nuova richiesta("ELIMINARE", apiUrl, zero)
 richiesta. Intestazione. Impostato("Tipo di contenuto", "applicazione/json; set di caratteri=utf-8")
 cliente := &http. Cliente{}
 risposta, errore := client. Fare (richiesta)
Se errore != zero {
 fmt. Println (errore)
 }
 fmt. Stampaln("Stato: ", risposta. Stato)
}

Una richiesta DELETE non accetta né restituisce un corpo, quindi il motivo per cui non è necessario analizzare o formattare la richiesta JSON e il corpo della risposta. La risposta restituisce solo uno stato per indicare l'esito positivo o negativo. Ecco come appare una chiamata di esempio alla funzione con il suo output:

funzprincipale() {
 fmt. Stampaln("Eseguo una richiesta di CANCELLAZIONE...")
 cancellautente("2")
}

Produzione:

Risparmia tempo utilizzando il http. Inviare() E http. Ottenere() metodi dal rete/http pacchetto da realizzare INVIARE E OTTENERE richieste direttamente, senza dover utilizzare il Nuova richiesta() funzione e il Cliente{} struttura per creare ed effettuare la richiesta separatamente. Dai un'occhiata al documentazione net/http per maggiori informazioni.

Esecuzione di richieste HTTP nelle applicazioni Go

IL http package in Go fornisce tutto il necessario per effettuare richieste HTTP e gestire le risposte nelle applicazioni Go. Le funzioni e le strutture fornite dal pacchetto consentono di creare e inviare diversi tipi di richieste come GET, POST, PUT, DELETE e molte altre.

Ciò semplifica la creazione di applicazioni Web in Go che possono interagire con altri servizi Web e API. Un buon modo per ottenere avere più familiarità con l'esecuzione di richieste HTTP in Go è la creazione di un'applicazione che effettua richieste a un'altra API REST di il tuo.