Richiesta di Golang HTTP

Una richiesta HTTP si riferisce a un'azione eseguita da un client HTTP su una risorsa specifica HTTP (Protocol). La risorsa è principalmente identificata da un URL come un nome di dominio o un indirizzo IP.

Le richieste HTTP sono uno dei blocchi più edili del Web moderno. Utilizzando la richiesta HTTP, possiamo richiedere risorse come pagine Web, video, immagini e altri file da un server remoto.

In questo articolo, impareremo come costruire un client HTTP di base utilizzando il linguaggio di programmazione Go.

Requisiti

In questo articolo, avrai bisogno delle seguenti risorse:

1. Vai al compilatore installato sul tuo sistema.
2. Conoscenza di base.
3. Un editor di testo.

Http get

Il primo metodo che stiamo per implementare è il metodo HTTP Get. Un metodo GET ci consente di richiedere i dati da una risorsa specificata. Ad esempio, quando dobbiamo recuperare articoli dal Linuxhint.com server, utilizziamo un metodo Get.

Il primo passo è assicurarti di configurare il tuo progetto. Se non hai familiarità con come creare e lavorare con un progetto Go, controlla il nostro tutorial sull'installazione di GO.

Una volta creato il progetto, apri il file GO principale e importa il pacchetto net/http dalla libreria standard GO.

Il pacchetto Net/HTTP ci fornisce la funzionalità e le utility per effettuare la richiesta HTTP ai server remoti.

Importa il pacchetto Net/HTTP aggiungendo la riga di seguito nel file GO.

importazione (
"net/http"
)

Nel pacchetto net/http, esiste un metodo GET che ci consente di realizzare metodi HTTP. La sintassi della funzione è come mostrato di seguito:

Func Get (URL String) (Resp *Response, Err Error)

La funzione prende un URL come argomento e restituisce la risposta come puntatore alla struttura e un errore (se presente).

Se il metodo non riscontra un errore, la risposta restituita contiene il corpo di risposta dalla risorsa richiesta.

Per utilizzare il metodo GET, possiamo creare codice come mostrato:

resp, err: = http.Get ("https: // API.SpaceXData.com/v4/lancio/ultimo ")
Se err != nil
tronco d'albero.Fatale (err)

Nell'esempio sopra, chiamiamo il metodo GET e passiamo l'URL alla risorsa a cui desideriamo accedere come stringa.

Nel nostro esempio, usiamo l'API SpaceX.

Come noterai, la funzione restituisce due valori che archiviamo in due variabili: resp ed err che contiene rispettivamente la risposta restituita e l'errore.

Tieni presente che il RESP non contiene altro che un puntatore alla struttura che tiene i dati effettivi. Quindi, se proviamo a stamparlo, avremo un sacco di dati confusi.

Un output di esempio dalla richiesta sopra è come mostrato di seguito:

Per noi per visualizzare i dati effettivi, dobbiamo accedere alla proprietà del corpo sulla struttura restituita. Dobbiamo quindi leggerlo e stamparlo sulla console o salvarlo in un file.

Per questo, possiamo usare l'IoUtil.Metodo Readme. Questo metodo è definito nel pacchetto IoUtil. Restituisce il corpo di risposta e un errore.

Nota: dopo aver letto il corpo di risposta, dobbiamo chiuderlo per evitare se dal bloccare altre operazioni nel programma.

Possiamo farlo impostando il metodo Close da eseguire dopo che la funzione principale è stata finta. La parola chiave Defer in go è disponibile.

Il resp.Corpo.Close () ci consente di chiudere il corpo di risposta dopo la lettura. Una volta letto il corpo di risposta, possiamo stamparlo alla console come implementato nel codice seguente:

Dai un'occhiata al nostro tutorial su Golang Defer per saperne di più

Pacchetto principale
importazione (
"FMT"
"Io/IoUtil"
"tronco d'albero"
"net/http"
)
func main ()
resp, err: = http.Get ("https: // API.SpaceXData.com/v4/lancio/ultimo ")
Se err != nil
tronco d'albero.Fatale (err)

// Close Body
differire resp.Corpo.Vicino()
// Leggi il corpo
corpo, err: = Ioutil.Readall (resp.Corpo)
Se err != nil
tronco d'albero.Fatale (err)

Il codice sopra implementa un client HTTP in GO in grado di rendere HTTP Ottieni una richiesta al metodo specificato.

Un valore di restituzione di esempio è come mostrato:

Per una migliore leggibilità, è possibile formattare la risposta in formato JSON leggibile o eseguire il maresciallo e lo sbalzo per selezionare l'output desiderato.

Controlla il nostro tutorial su JSON Marshal e Unmarshal per saperne di più.

Post http

La parte successiva di un client HTTP sta effettuando il metodo post post. Un metodo HTTP consente di inviare dati al server ed eseguire un'azione sulla risorsa specificata. Ciò potrebbe creare, eliminare o aggiornare una risorsa.

In GO, possiamo effettuare la richiesta di post utilizzando il pacchetto net/http. Ci fornisce il metodo post, che ci consente di inviare dati a un server.

La sintassi della funzione è come mostrato di seguito:

Func Post (URL, contentType String, Body IO.Lettore) (resp *risposta, errore ERR)

La funzione prende tre argomenti:

1. L'indirizzo della risorsa.
2. Il tipo di contenuto del corpo da inviare al server, una stringa
3. Il corpo della richiesta di tipo io.Lettore

La funzione dovrebbe quindi restituire la risposta e un errore. Tieni presente che dobbiamo convertire i dati da inviare al server in un formato accettabile. Possiamo farlo convertendo i dati JSON in IO.Lettore, che è fondamentalmente un'interfaccia in Go.

Controlla il codice sorgente per saperne di più.

Convertire i dati JSON in IO.Il tipo di lettore prevede due passaggi:

Il primo è codificare i dati JSON in formato byte. Possiamo farlo da JSON MASHALING come discusso nel nostro tutorial.

Una volta codificati, possiamo convertire i dati in tipo come implementato da IO.Interfaccia del lettore usando il metodo Newbuffer. Questo metodo restituisce l'IO.Tipo di lettore che possiamo quindi passare al metodo post.

Un blocco di codice di esempio è come mostrato di seguito:

corpo, _: = json.Marshal (mappa [string] string
"id": "1",
"Sito": "Linuxhint"
)
encoded_json: = bytes.NewBuffer (Body)

Una volta che abbiamo tutte le parti in ordine, possiamo invocare il metodo post alla risorsa specificata. Tieni presente che questo tutorial utilizza dati e collegamenti fittizi.

Pacchetto principale
importazione (
"byte"
"codifica/json"
"FMT"
"Io/IoUtil"
"tronco d'albero"
"net/http"
)
func main ()
corpo, _: = json.Marshal (mappa [string] string
"id": "1",
"Sito": "Linuxhint"
)
resp, err: = http.Post ("http: // esempio.com/v4/endpoint/post "," applicazione/json ", corpo)
Se err != nil
tronco d'albero.Fatale (err)

differire resp.Corpo.Vicino()
return_body, err: = Ioutil.Readall (resp.Corpo)
Se err != nil
tronco d'albero.Fatale (err)

fmt.Println (string (body))

Il metodo sopra implementa un semplice client HTTP in grado di rendere i metodi HTTP post a una risorsa specificata.

Conclusione

Questo articolo mostra come costruire un client HTTP fondamentale utilizzando il linguaggio di programmazione Go. GO è eccezionalmente veloce quando si tratta di servire HTTP. Utilizzando le conoscenze in questo articolo, è possibile espandere il client a un'applicazione pienamente fatta.

Continua a codificare.