Hogyan készítsünk HTTP-kéréseket a Go-ban

A világháló működését irányító egyik alapelv a kérések és válaszok cseréje. Amikor kérelmet küld egy weboldal elérésére, a szerver a megfelelő adatokkal válaszol.

A különböző típusú internetes kommunikációt szabályozó népszerű protokollok közé tartozik HTTP (Hypertext Transfer Protocol), FTP (Fájlátviteli protokoll), és SMTP (Simple Mail Transfer Protocol).

A HTTP az a protokoll, amelyet általában akkor használ, amikor megtekint egy webhelyet vagy egy web-kompatibilis alkalmazást használ. Számos programozási nyelvből, köztük a Go-ból származó HTTP-kérésekkel is dolgozhat.

Mi az a HTTP-kérés?

A HTTP határozza meg, hogy az ügyfelek, például a webböngészők hogyan küldenek kéréseket a szervereknek, amelyek aztán választ adnak vissza. A HTTP-kérés információkat tartalmaz az ügyfél által elérni kívánt erőforrásról. A kérésüzenet jellemzően egy URL-t tartalmaz, amely azonosítja az erőforrást, és egyéb opcionális adatokat, például fejléceket és lekérdezési paramétereket.

Vannak többféle HTTP kérés, beleértve a GET, POST, PUT, DELETE, HEAD, OPTIONS és CONNECT. Az első négy módszertípus a leggyakoribb; tükrözik a CRUD olvasási, létrehozási, frissítési és törlési műveleteit.

A PUT kéréstípust gyakran felváltva használják a PATCH kéréstípussal. Ugyanazt a célt érik el, csak abban különböznek, hogy milyen adatokat várnak el a kérelemben.

Kérések küldése általános HTTP-módszerekkel

A Go beépített http csomag funkciókat és struktúrákat biztosít, amelyek segítségével webszervereket hozhat létre és HTTP-kéréseket kezelhet. Ez egy nagyon robusztus csomag, és minden Go webes keretrendszer valamilyen módon erre épül. Ez a Go alcsomagja háló csomag.

HTTP-kérés létrehozásához a Go alkalmazásban használhatja a http. NewRequest() függvényt, és állítsa be a megfelelő metódust, URL-t, fejléceket és kérés törzsét. A kérelem létrehozása után használhatja a Go net/http csomagok http. Ügyfél{} futtatásához és a válasz fogadásához.

A következő kódmintákat használjuk reqres.in, egy nyilvánosan elérhető API a HTTP-kérelmek tesztelésére. Használhatja a GET, POST, PUT és DELETE kérések tesztelésére a Go programjaiban.

POST-kérés

Az alábbi kód egy olyan funkció, amely POST kérést küld a /api/users A reqres.in végpontja új felhasználó létrehozásához névvel és feladattal.

csomag fő-
import (
"bájt"
"kódolás/json"
"fmt"
"io"
"net/http"
)
funcfelhasználó létrehozása(név, munkakör húr) {
 fmt. Println("Felhasználó létrehozása...")
 apiUrl := " https://reqres.in/api/users"
 felhasználói adatok := []byte(`{"név":"` + név + `","munka":"` + munka + `"}`)
// új http kérés létrehozása
 kérés, hiba := http. NewRequest("POST", apiUrl, bájtok. NewBuffer (felhasználói adatok))
 kérés. Fejléc. Készlet("Tartalom típus", "alkalmazás/json; charset=utf-8")
// küldje el a kérést
 kliens := &http. Ügyfél{}
 válasz, hiba := kliens. Tedd (kérés)
ha hiba != nulla {
 fmt. Println (hiba)
 }
 responseBody, error := io. Mindent olvas (válasz. Test)
ha hiba != nulla {
 fmt. Println (hiba)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Állapot:", válasz. Állapot)
 fmt. Println("Választörzs:", formattedData)
// memória tisztítása végrehajtás után
elhalasztja válasz. Test. Bezárás()
}

formatJSON egy egyéni függvény, amelyet írhat a kimeneti adatok formázásához. Így valósíthatja meg:

// függvény a JSON-adatok formázásához
funcformatJSON(adat []byte)húr {
var ki bájtokat. Puffer
 hiba := json. Behúzás(&out, adat, "", " ")
ha hiba! = nulla {
 fmt. Println (hiba)
 }
 d := ki. bájt()
Visszatéréshúrd)
}

Felhívhatja a felhasználó létrehozása() funkció egy ilyen programban:

funcfő-() {
 fmt. Println("POST kérés készítése...")
 felhasználó létrehozása("Tim Omolana", "Író")
}

Amikor a programot terminálon futtatja, használja a menj futni parancsot, a következő kimenetet fogja látni:

GET Kérés

A következő kód egy olyan függvény, amely GET-kérést küld a felhasználó lekérésére a reqres.in kiszolgálóról az egyedi azonosítójuk használatával.

// main.go
funcgetUser(id húr) {
 fmt. Println("Felhasználó lekérése azonosító alapján...")
// küldjön GET-kérelmet az API-nak a felhasználó azonosító szerinti lekéréséhez
 apiUrl := " https://reqres.in/api/users/" + id
 kérés, hiba := http. NewRequest("KAP", apiUrl, nulla)
ha hiba != nulla {
 fmt. Println (hiba)
 }
 kérés. Fejléc. Készlet("Tartalom típus", "alkalmazás/json; charset=utf-8")
 kliens := &http. Ügyfél{}
 válasz, hiba := kliens. Tedd (kérés)
ha hiba != nulla {
 fmt. Println (hiba)
 }
 responseBody, error := io. Mindent olvas (válasz. Test)
ha hiba != nulla {
 fmt. Println (hiba)
 }
 formattedData := formatJSON(responseBody)
 fmt. Println("Állapot:", válasz. Állapot)
 fmt. Println("Választörzs:", formattedData)
// memória tisztítása végrehajtás után
elhalasztja válasz. Test. Bezárás()
}

A GET kérés nem küld adatokat a szervernek, így nem fogad el vagy küld el kéréstörzset a szervernek, amikor megtörténik. Így fog kinézni a fenti függvény egy példahívása:

funcfő-() {
 fmt. Println("GET kérés benyújtása...")
 getUser("2")
}

Kimenet:

PUT kérés

A PUT kérés nagyon hasonlít a POST kérésre, mert adatokat is küld a szervernek. A fő különbség az, hogy a POST új erőforrást hoz létre, míg a PUT frissít egy meglévőt.

Íme egy PUT-kérés megvalósítása:

// main.go
funcupdateUser(név, munkakör, azonosító húr) {
 fmt. Println("Felhasználó frissítése...")
// küldjön PUT kérést az API-nak a felhasználó frissítéséhez
 apiUrl := " https://reqres.in/api/users/" + id
 felhasználói adatok := []byte(`{"név":"` + név + `","munka":"` + munka + `"}`)
// új http PUT kérés létrehozása
 kérés, hiba := http. NewRequest("PUT", apiUrl, bájtok. NewBuffer (felhasználói adatok))
 kérés. Fejléc. Készlet("Tartalom típus", "alkalmazás/json; charset=utf-8")
// A fennmaradó függvénytörzs a createUser függvényből...
// Kérelem benyújtása, válasz lekérése és memória törlése...
}

Ebből a kódból láthatja, hogy a fenti PUT kérés és a POST kérés között csak a metódus neve és az URL különbözik. Ha PUT-t használ a meglévő adatok frissítéséhez, hozzá kell adnia az azonosítót a kérelem URL-jéhez. Ennek a függvénynek a mintahívása így néz ki:

func main() {
// bejegyzés frissítése a 2. azonosítóval.
 updateUser("Tim Newname", "Személyi író", "2")
}

A fenti kód frissíti a felhasználót, és a következő kimenetet hozza létre:

TÖRLÉS kérés

Használja a DELETE kérési módszert törlési művelet végrehajtásához egy webszerveren. A törlési kérelem törli az URI által azonosított erőforrást. Egy TÖRLÉS kérés a Go alkalmazásban így néz ki:

funcdeleteUser(id húr) {
 fmt. Println("Felhasználó törlése...")
// küldjön DELETE kérést az API-nak a felhasználó törléséhez
 apiUrl := " https://reqres.in/api/users/" + id
// új http kérés létrehozása
 kérés, hiba := http. NewRequest("TÖRÖL", apiUrl, nulla)
 kérés. Fejléc. Készlet("Tartalom típus", "alkalmazás/json; charset=utf-8")
 kliens := &http. Ügyfél{}
 válasz, hiba := kliens. Tedd (kérés)
ha hiba != nulla {
 fmt. Println (hiba)
 }
 fmt. Println("Állapot:", válasz. Állapot)
}

A DELETE kérés nem fogad el és nem ad vissza törzset, ezért nincs szükség a JSON-kérelem és válasz törzsének elemzésére vagy formázására. A válasz csak a sikert vagy a kudarcot jelző állapotot ad vissza. Így néz ki a függvény mintahívása a kimenetével:

funcfő-() {
 fmt. Println("TÖRLÉS kérés benyújtása...")
 deleteUser("2")
}

Kimenet:

Takarítson meg időt a http. Post() és http. Kap() módszerek a net/http csomag elkészítése POST és KAP közvetlenül kéri, anélkül, hogy a NewRequest() funkció és a Ügyfél{} a kérés külön létrehozásához és benyújtásához. Nézze meg a net/http dokumentáció további információért.

HTTP-kérések készítése a Go alkalmazásokban

A http csomag a Goban mindent biztosít, ami a HTTP-kérésekhez és a válaszok kezeléséhez szükséges a Go alkalmazásokban. A csomag által biztosított funkciók és struktúrák lehetővé teszik különféle kérések létrehozását és küldését, mint például GET, POST, PUT, DELETE és még sok más.

Ez megkönnyíti a Go-ban olyan webalkalmazások készítését, amelyek képesek együttműködni más webszolgáltatásokkal és API-kkal. Jó módja annak, hogy megszerezzük jobban ismeri a HTTP-kéréseket a Go-ban, ha olyan alkalmazást készít, amely kéréseket küld egy másik REST API-hoz a tiéd.