Hvordan lage HTTP-forespørsler i Go

Et av de grunnleggende prinsippene som styrer hvordan World Wide Web fungerer, er utveksling av forespørsler og svar. Når du sender en forespørsel om å få tilgang til en nettside, svarer serveren med passende data.

Populære protokoller som styrer ulike typer internettkommunikasjon inkluderer HTTP (Hypertext Transfer Protocol), FTP (Filoverføringsprotokoll), og SMTP (Simple Mail Transfer Protocol).

HTTP er protokollen du vanligvis bruker når du ser på et nettsted eller bruker en nettaktivert app. Du kan også jobbe med HTTP-forespørsler fra mange programmeringsspråk, inkludert Go.

Hva er en HTTP-forespørsel?

HTTP definerer hvordan klienter, som nettlesere, sender forespørsler til servere som deretter returnerer et svar. En HTTP-forespørsel inneholder informasjon om en ressurs klienten prøver å få tilgang til. Forespørselsmeldingen omfatter vanligvis en URL som identifiserer ressursen og andre valgfrie data som overskrifter og spørringsparametere.

Det er flere typer HTTP-forespørsel, inkludert GET, POST, PUT, DELETE, HEAD, OPTIONS og CONNECT. De fire første metodetypene er de vanligste; de speiler CRUD-operasjonene henholdsvis lese, opprette, oppdatere og slette.

PUT-forespørselstypen brukes ofte om hverandre med PATCH-forespørselstypen. De oppnår samme formål, de er bare forskjellige i dataene de forventer at forespørselen skal inkludere.

Sende forespørsler ved å bruke vanlige HTTP-metoder

Go er innebygd http pakke gir et sett med funksjoner og strukturer du kan bruke til å lage webservere og administrere HTTP-forespørsler. Det er en veldig robust pakke, og alle Go-nettrammeverk bygger på den ene eller andre måten. Det er en underpakke av Go's nett pakke.

For å opprette en HTTP-forespørsel i Go, kan du bruke http. NewRequest() funksjon og angi riktig metode, URL, overskrifter og forespørselstekst. Etter å ha opprettet forespørselen, kan du bruke Go net/http pakkens http. Klient{} struktur for å kjøre den og motta responsen.

Følgende kodeeksempler bruker reqres.in, et offentlig tilgjengelig API for testing av HTTP-forespørsler. Du kan bruke den til å teste GET-, POST-, PUT- og DELETE-forespørsler i Go-programmene dine.

POST-forespørsel

Koden nedenfor er en funksjon som sender en POST-forespørsel til /api/users endepunkt av reqres.in for å opprette en ny bruker med et navn og en jobb.

pakke hoved-
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
)
funcOpprett bruker(navn, jobb streng) {
 fmt. Println("Oppretter bruker...")
 apiUrl := " https://reqres.in/api/users"
 brukerdata := []byte(`{"navn":"` + navn + `","jobb":"` + jobb + `"}`)
// opprette ny http-forespørsel
 forespørsel, feil := http. NewRequest("POST", apiUrl, bytes. NewBuffer (brukerdata))
 be om. Overskrift. Sett("Innholdstype", "applikasjon/json; charset=utf-8")
// send forespørselen
 klient := &http. Klient{}
 svar, feil := klient. Gjør (forespørsel)
hvis feil != null {
 fmt. Println (feil)
 }
 responseBody, feil := io. Les alle (svar. Kropp)
hvis feil != null {
 fmt. Println (feil)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Status: ", respons. Status)
 fmt. Println("Svarstekst: ", formatert data)
// Rydd opp i minnet etter kjøring
utsette respons. Kropp. Lukk()
}

formatJSON er en tilpasset funksjon du kan skrive for å formatere utdataene. Slik kan du implementere det:

// funksjon for å formatere JSON-data
funcformatJSON(data []byte)streng {
var ut byte. Buffer
 feil := json. Innrykk(&ut, data, "", " ")
hvis feil!= null {
 fmt. Println (feil)
 }
 d := ut. Bytes()
komme tilbakestreng(d)
}

Du kan ringe til Opprett bruker() funksjon i et program som dette:

funchoved-() {
 fmt. Println("Gjør POST-forespørsel ...")
 Opprett bruker("Tim Omolana", "Forfatter")
}

Når du kjører programmet i en terminal, bruker du gå løp kommando, vil du se utdata som dette:

FÅ forespørsel

Følgende kode er en funksjon som sender en GET-forespørsel for å hente en bruker fra reqres.in-serveren ved å bruke deres unike ID.

// main.go
funcgetUser(id streng) {
 fmt. Println("Henter bruker etter ID...")
// gjør GET-forespørsel til API for å få bruker etter ID
 apiUrl := " https://reqres.in/api/users/" + id
 forespørsel, feil := http. NewRequest("FÅ", apiUrl, null)
hvis feil != null {
 fmt. Println (feil)
 }
 be om. Overskrift. Sett("Innholdstype", "applikasjon/json; charset=utf-8")
 klient := &http. Klient{}
 svar, feil := klient. Gjør (forespørsel)
hvis feil != null {
 fmt. Println (feil)
 }
 responseBody, feil := io. Les alle (svar. Kropp)
hvis feil != null {
 fmt. Println (feil)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Status: ", respons. Status)
 fmt. Println("Svarstekst: ", formatert data)
// Rydd opp i minnet etter kjøring
utsette respons. Kropp. Lukk()
}

En GET-forespørsel sender ikke data til serveren, så den godtar eller sender ikke en forespørselstekst til serveren når den gjøres. Slik vil et eksempeloppkall til funksjonen ovenfor se ut:

funchoved-() {
 fmt. Println("Ger GET-forespørsel ...")
 getUser("2")
}

Produksjon:

PUT-forespørsel

PUT-forespørselen er veldig lik en POST-forespørsel fordi den også sender data til serveren. Den største forskjellen er at POST oppretter en ny ressurs mens PUT oppdaterer en eksisterende.

Her er en implementering av en PUT-forespørsel:

// main.go
funcoppdater bruker(navn, jobb, id streng) {
 fmt. Println("Oppdaterer bruker...")
// gjør PUT-forespørsel til API for å oppdatere bruker
 apiUrl := " https://reqres.in/api/users/" + id
 brukerdata := []byte(`{"navn":"` + navn + `","jobb":"` + jobb + `"}`)
// opprette ny http PUT-forespørsel
 forespørsel, feil := http. NewRequest("SETTE", apiUrl, bytes. NewBuffer (brukerdata))
 be om. Overskrift. Sett("Innholdstype", "applikasjon/json; charset=utf-8")
// Gjenværende funksjonstekst fra createUser-funksjonen...
// Kom med forespørsel, få svar og tøm minnet...
}

Fra denne koden kan du se de eneste forskjellene mellom PUT-forespørselen og POST-forespørselen ovenfor er metodenavnet og URL-en. Når du bruker en PUT for å oppdatere eksisterende data, må du legge til ID-en til forespørsels-URLen. Et eksempeloppkall til denne funksjonen vil se slik ut:

func main() {
// oppdater oppføringen med ID 2.
 oppdater bruker("Tim Newname", "Stabsskribent", "2")
}

Koden ovenfor oppdaterer brukeren og produserer følgende utdata:

SLETT forespørsel

Bruk DELETE request-metoden for å utføre en sletteoperasjon på en webserver. En sletteforespørsel sletter ressursen identifisert av URI. En SLETTE-forespørsel i Go ser slik ut:

funcslett bruker(id streng) {
 fmt. Println("Sletter bruker...")
// gjør DELETE-forespørsel til API for å slette bruker
 apiUrl := " https://reqres.in/api/users/" + id
// opprette ny http-forespørsel
 forespørsel, feil := http. NewRequest("SLETT", apiUrl, null)
 be om. Overskrift. Sett("Innholdstype", "applikasjon/json; charset=utf-8")
 klient := &http. Klient{}
 svar, feil := klient. Gjør (forespørsel)
hvis feil != null {
 fmt. Println (feil)
 }
 fmt. Println("Status: ", respons. Status)
}

En SLETT-forespørsel verken godtar eller returnerer en kropp, derav grunnen til at det ikke er behov for å analysere eller formatere JSON-forespørselen og svarteksten. Svaret returnerer bare en status for å indikere suksess eller fiasko. Slik ser et eksempelkall til funksjonen ut med utdata:

funchoved-() {
 fmt. Println("Gjør SLETT-forespørsel...")
 slettBruker("2")
}

Produksjon:

Spar tid ved å bruke http. Post() og http. Få() metoder fra net/http pakke å lage POST og FÅ forespørsler direkte, uten å måtte bruke NewRequest() funksjon og Klient{} struktur for å opprette og lage forespørselen separat. Sjekk ut net/http-dokumentasjon for mer informasjon.

Foreta HTTP-forespørsler i Go-applikasjoner

De http pakken i Go gir alt som trengs for å lage HTTP-forespørsler og håndtere svar i Go-applikasjoner. Funksjonene og strukturene som tilbys av pakken lar deg opprette og sende forskjellige typer forespørsler som GET, POST, PUT, DELETE og mange flere.

Dette gjør det enkelt å bygge nettapplikasjoner i Go som kan samhandle med andre nettjenester og APIer. En god måte å få mer kjent med å lage HTTP-forespørsler i Go er å bygge en applikasjon som sender forespørsler til en annen REST API av din.