Hur man gör HTTP-förfrågningar i Go

En av de grundläggande principerna som styr hur World Wide Web fungerar är utbytet av förfrågningar och svar. När du skickar en begäran om att få tillgång till en webbsida svarar servern med lämplig data.

Populära protokoll som styr olika typer av internetkommunikation inkluderar HTTP (Hypertext Transfer Protocol), FTP (Filöverföringsprotokoll), och SMTP (Simple Mail Transfer Protocol).

HTTP är det protokoll du vanligtvis använder när du tittar på en webbplats eller använder en webbaktiverad app. Du kan också arbeta med HTTP-förfrågningar från många programmeringsspråk, inklusive Go.

Vad är en HTTP-förfrågan?

HTTP definierar hur klienter, som webbläsare, skickar förfrågningar till servrar som sedan returnerar ett svar. En HTTP-förfrågan innehåller information om en resurs som klienten försöker komma åt. Förfrågningsmeddelandet innefattar vanligtvis en URL som identifierar resursen och andra valfria data som rubriker och frågeparametrar.

Det finns flera typer av HTTP-förfrågningar, inklusive GET, POST, PUT, DELETE, HEAD, OPTIONS och CONNECT. De fyra första metodtyperna är de vanligaste; de speglar CRUD-operationerna läsa, skapa, uppdatera respektive ta bort.

PUT-begärantypen används ofta omväxlande med PATCH-begärantypen. De uppnår samma syfte, de skiljer sig bara åt i de uppgifter de förväntar sig att begäran ska innehålla.

Skicka förfrågningar med vanliga HTTP-metoder

Go’s inbyggda http paket tillhandahåller en uppsättning funktioner och strukturer som du kan använda för att skapa webbservrar och hantera HTTP-förfrågningar. Det är ett mycket robust paket och alla Go-webbramverk bygger ovanpå det på ett eller annat sätt. Det är ett underpaket av Go’s netto paket.

För att skapa en HTTP-förfrågan i Go kan du använda http. Ny förfrågan() funktion och ställ in lämplig metod, URL, rubriker och förfrågningstext. När du har skapat begäran kan du använda Go net/http paketets http. Klient{} struktur för att köra det och ta emot svaret.

Följande kodexempel använder reqres.in, ett allmänt tillgängligt API för att testa HTTP-förfrågningar. Du kan använda den för att testa GET, POST, PUT och DELETE-förfrågningar i dina Go-program.

POST-förfrågan

Koden nedan är en funktion som skickar en POST-förfrågan till /api/users endpoint för reqres.in för att skapa en ny användare med ett namn och ett jobb.

paket huvud
importera (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
)
funcskapa användare(namn, jobb sträng) {
 fmt. Println("Skapar användare...")
 apiUrl := " https://reqres.in/api/users"
 användardata := []byte(`{"namn":"` + namn + `","jobb":"` + jobb + `"}`)
// skapa ny http-förfrågan
 begäran, fel := http. Ny förfrågan("POSTA", apiUrl, bytes. NewBuffer (användardata))
 begäran. Rubrik. Uppsättning("Innehållstyp", "applikation/json; charset=utf-8")
// skicka förfrågan
 klient := &http. Klient{}
 svar, fel := klient. Gör (begär)
om fel != noll {
 fmt. Println (fel)
 }
 responseBody, fel := io. Läs allt (svar. Kropp)
om fel != noll {
 fmt. Println (fel)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Status: ", svar. Status)
 fmt. Println("Svarsdel: ", formaterad data)
// rensa upp minnet efter körning
uppskjuta svar. Kropp. Stänga()
}

formatJSON är en anpassad funktion som du kan skriva för att formatera utdata. Så här kan du implementera det:

// funktion för att formatera JSON-data
funcformatJSON(data []byte)sträng {
var ut bytes. Buffert
 fel := json. Indrag(&ut, data, "", " ")
om fel!= noll {
 fmt. Println (fel)
 }
 d := ut. Bytes()
lämna tillbakasträng(d)
}

Du kan ringa till skapa användare() funktion i ett program som detta:

funchuvud() {
 fmt. Println("Gör POST-begäran...")
 skapa användare("Tim Omolana", "Författare")
}

När du kör programmet i en terminal använder du springa kommando kommer du att se utdata så här:

GET-förfrågan

Följande kod är en funktion som skickar en GET-begäran för att hämta en användare från reqres.in-servern med deras unika ID.

// main.go
funcgetUser(id sträng) {
 fmt. Println("Hämtar användare efter ID...")
// gör GET-begäran till API för att få användare efter ID
 apiUrl := " https://reqres.in/api/users/" + id
 begäran, fel := http. Ny förfrågan("SKAFFA SIG", apiUrl, noll)
om fel != noll {
 fmt. Println (fel)
 }
 begäran. Rubrik. Uppsättning("Innehållstyp", "applikation/json; charset=utf-8")
 klient := &http. Klient{}
 svar, fel := klient. Gör (begär)
om fel != noll {
 fmt. Println (fel)
 }
 responseBody, fel := io. Läs allt (svar. Kropp)
om fel != noll {
 fmt. Println (fel)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Status: ", svar. Status)
 fmt. Println("Svarsdel: ", formaterad data)
// rensa upp minnet efter körning
uppskjuta svar. Kropp. Stänga()
}

En GET-begäran skickar inte data till servern så den accepterar eller skickar inte en begäran till servern när den görs. Så här kommer ett exempelanrop till funktionen ovan att se ut:

funchuvud() {
 fmt. Println("Gör GET-förfrågan...")
 getUser("2")
}

Produktion:

PUT-förfrågan

PUT-begäran är mycket lik en POST-begäran eftersom den också skickar data till servern. Den stora skillnaden är att POST skapar en ny resurs medan PUT uppdaterar en befintlig.

Här är en implementering av en PUT-begäran:

// main.go
funcuppdateraAnvändare(namn, jobb, id sträng) {
 fmt. Println("Uppdaterar användare...")
// gör PUT-begäran till API för att uppdatera användaren
 apiUrl := " https://reqres.in/api/users/" + id
 användardata := []byte(`{"namn":"` + namn + `","jobb":"` + jobb + `"}`)
// skapa ny http PUT-förfrågan
 begäran, fel := http. Ny förfrågan("SÄTTA", apiUrl, bytes. NewBuffer (användardata))
 begäran. Rubrik. Uppsättning("Innehållstyp", "applikation/json; charset=utf-8")
// Återstående funktionskropp från createUser-funktionen...
// Gör en begäran, få svar och rensa minnet...
}

Från den här koden kan du se de enda skillnaderna mellan PUT-begäran och POST-begäran ovan är metodnamnet och URL: en. När du använder en PUT för att uppdatera befintliga data, måste du lägga till id: t till förfrågningsadressen. Ett exempel på anrop till den här funktionen skulle se ut så här:

func main() {
// uppdatera posten med ID 2.
 uppdateraUser("Tim Newname", "Stabsskribent", "2")
}

Koden ovan uppdaterar användaren och producerar följande utdata:

DELETE Begäran

Använd DELETE-begäran för att utföra en raderingsoperation på en webbserver. En raderingsbegäran tar bort resursen som identifierats av URI: n. En DELETE-förfrågan i Go ser ut så här:

functa bortAnvändare(id sträng) {
 fmt. Println("Tar bort användare...")
// gör DELETE-begäran till API för att ta bort användare
 apiUrl := " https://reqres.in/api/users/" + id
// skapa ny http-förfrågan
 begäran, fel := http. Ny förfrågan("RADERA", apiUrl, noll)
 begäran. Rubrik. Uppsättning("Innehållstyp", "applikation/json; charset=utf-8")
 klient := &http. Klient{}
 svar, fel := klient. Gör (begär)
om fel != noll {
 fmt. Println (fel)
 }
 fmt. Println("Status: ", svar. Status)
}

En DELETE-begäran varken accepterar eller returnerar en text, därav anledningen till att det inte finns något behov av att analysera eller formatera JSON-begäran och svarskroppen. Svaret returnerar endast en status för att indikera framgång eller misslyckande. Så här ser ett exempelanrop till funktionen ut med dess utdata:

funchuvud() {
 fmt. Println("Gör DELETE-begäran...")
 ta bortAnvändare("2")
}

Produktion:

Spara tid genom att använda http. Posta() och http. Skaffa sig() metoder från net/http paket att göra POSTA och SKAFFA SIG förfrågningar direkt, utan att behöva använda Ny förfrågan() funktion och Klient{} struktur för att skapa och göra begäran separat. Kolla in net/http-dokumentation för mer information.

Göra HTTP-förfrågningar i Go-applikationer

De http paket i Go tillhandahåller allt som behövs för att göra HTTP-förfrågningar och hantera svar i Go-applikationer. Funktionerna och strukturerna som tillhandahålls av paketet gör att du kan skapa och skicka olika typer av förfrågningar som GET, POST, PUT, DELETE och många fler.

Detta gör det enkelt att bygga webbapplikationer i Go som kan interagera med andra webbtjänster och API: er. Ett bra sätt att få mer bekant med att göra HTTP-förfrågningar i Go är att bygga en applikation som gör förfrågningar till en annan REST API av din.